text stringlengths 14 6.51M |
|---|
unit frmAddLibraryPathU;
{$WARN SYMBOL_PLATFORM OFF}
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, System.UITypes,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
Vcl.ExtCtrls, Vcl.Buttons, LibraryHelperU, Vcl.Menus,
System.Actions, Vcl.ActnList, System.ImageList, Vcl.ImgList;
type
TfrmAddLibraryPath = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
GroupBoxDestination: TGroupBox;
GridPanel1: TGridPanel;
cbAndroid32: TCheckBox;
cbIOS32: TCheckBox;
cbIOS64: TCheckBox;
cbIOSSimulator: TCheckBox;
cbOSX: TCheckBox;
cbWin32: TCheckBox;
cbWin64: TCheckBox;
Label1: TLabel;
PopupMenuDestinations: TPopupMenu;
CheckAll1: TMenuItem;
UncheckAll1: TMenuItem;
ActionList: TActionList;
ActionOk: TAction;
ActionCancel: TAction;
Panel3: TPanel;
editPath: TComboBox;
BitBtn3: TBitBtn;
ActionSelectFolder: TAction;
cbLinux64: TCheckBox;
procedure CheckAll1Click(Sender: TObject);
procedure UncheckAll1Click(Sender: TObject);
procedure ActionCancelExecute(Sender: TObject);
procedure ActionOkExecute(Sender: TObject);
procedure ActionSelectFolderExecute(Sender: TObject);
procedure editPathDropDown(Sender: TObject);
procedure ActionOkUpdate(Sender: TObject);
private
FDelphiLibrary: TDelphiLibrary;
FDelphiInstallation: TDelphiInstallation;
procedure SetDestinationsChecked(AValue: Boolean);
procedure SetFormValues;
procedure UpdatePathVariables;
public
function Add(ADelphiLibrary: TDelphiLibrary;
ADelphiInstallation: TDelphiInstallation): Boolean;
end;
implementation
{$R *.dfm}
uses
dmDelphiLibraryHelperU;
{ TfrmAddLibraryPath }
procedure TfrmAddLibraryPath.ActionCancelExecute(Sender: TObject);
begin
Self.ModalResult := mrCancel;
end;
procedure TfrmAddLibraryPath.ActionOkExecute(Sender: TObject);
var
LSuccess: Boolean;
begin
LSuccess := False;
if Trim(editPath.Text) <> '' then
begin
if cbAndroid32.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlAndroid32);
if cbIOS32.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlIOS32);
if cbIOS64.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlIOS64);
if cbIOSSimulator.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlIOSimulator);
if cbOSX.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlOSX32);
if cbWin32.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlWin32);
if cbWin64.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlWin64);
if cbLinux64.Checked then
LSuccess := FDelphiInstallation.AddPath(editPath.Text, dlLinux64);
end;
if LSuccess then
begin
Self.ModalResult := mrOk;
end
else
begin
MessageDlg(Format('Failed to add path "%s", please ensure it is valid',
[editPath.Text]), mtError, [mbOK], 0);
end;
end;
procedure TfrmAddLibraryPath.ActionOkUpdate(Sender: TObject);
begin
ActionOk.Enabled := Trim(editPath.Text) <> '';
end;
procedure TfrmAddLibraryPath.ActionSelectFolderExecute(Sender: TObject);
begin
with TFileOpenDialog.Create(nil) do
try
Options := [fdoPickFolders];
if Execute then
begin
editPath.Text := FileName;
end;
finally
Free;
end;
end;
function TfrmAddLibraryPath.Add(ADelphiLibrary: TDelphiLibrary;
ADelphiInstallation: TDelphiInstallation): Boolean;
begin
FDelphiLibrary := ADelphiLibrary;
FDelphiInstallation := ADelphiInstallation;
SetFormValues;
Result := Self.ShowModal = mrOk;
end;
procedure TfrmAddLibraryPath.CheckAll1Click(Sender: TObject);
begin
SetDestinationsChecked(True);
end;
procedure TfrmAddLibraryPath.editPathDropDown(Sender: TObject);
begin
UpdatePathVariables;
end;
procedure TfrmAddLibraryPath.SetDestinationsChecked(AValue: Boolean);
begin
cbAndroid32.Checked := AValue;
cbIOS32.Checked := AValue;
cbIOS64.Checked := AValue;
cbIOSSimulator.Checked := AValue;
cbOSX.Checked := AValue;
cbWin32.Checked := AValue;
cbWin64.Checked := AValue;
cbLinux64.Checked := AValue;
end;
procedure TfrmAddLibraryPath.SetFormValues;
begin
SetDestinationsChecked(False);
case FDelphiLibrary of
dlAndroid32:
cbAndroid32.Checked := True;
dlIOS32:
cbIOS32.Checked := True;
dlIOS64:
cbIOS64.Checked := True;
dlIOSimulator:
cbIOSSimulator.Checked := True;
dlOSX32:
cbOSX.Checked := True;
dlWin32:
cbWin32.Checked := True;
dlWin64:
cbWin64.Checked := True;
dlLinux64:
cbLinux64.Checked := True;
end;
end;
procedure TfrmAddLibraryPath.UncheckAll1Click(Sender: TObject);
begin
SetDestinationsChecked(False);
end;
procedure TfrmAddLibraryPath.UpdatePathVariables;
var
LIdx: Integer;
LName, LPath: string;
begin
editPath.Items.BeginUpdate;
try
editPath.Items.Add('$(BDS)');
for LIdx := 0 to Pred(FDelphiInstallation.EnvironmentVariables.Count) do
begin
LPath := FDelphiInstallation.EnvironmentVariables.Variable[LIdx].Value;
LName := FDelphiInstallation.EnvironmentVariables.Variable[LIdx].Name;
if DirectoryExists(LPath) then
begin
editPath.Items.Add(Format('$(%s)\', [LName]));
end;
end;
for LIdx := 0 to Pred
(FDelphiInstallation.SystemEnvironmentVariables.Count) do
begin
LPath := FDelphiInstallation.SystemEnvironmentVariables.Variable
[LIdx].Value;
LName := FDelphiInstallation.SystemEnvironmentVariables.Variable
[LIdx].Name;
if DirectoryExists(LPath) then
begin
editPath.Items.Add(Format('$(%s)\', [LName]));
end;
end;
finally
editPath.Items.EndUpdate;
end;
end;
end.
|
{..............................................................................}
{ Summary Fetch existing violation objects and generate a report outlining }
{ different violations. }
{ Copyright (c) 2004 by Altium Limited }
{..............................................................................}
{..............................................................................}
Function ConvertRuleLayerKindToString(K : TRuleLayerKind) : String;
Begin
Result := '';
Case K Of
eRuleLayerKind_SameLayer : Result := 'Same Layer';
eRuleLayerKind_AdjacentLayer : Result := 'AdjacentLayer';
End;
End;
{..............................................................................}
{..............................................................................}
Function ConvertRuleKindToString(R : TRuleKind) : String;
Begin
Result := '';
Case R Of
eRule_Clearance : Result := 'Clearance';
eRule_ParallelSegment : Result := 'Parallel Segment';
eRule_MaxMinWidth : Result := 'Max min Width';
eRule_MaxMinLength : Result := 'Max min length';
eRule_MatchedLengths : Result := 'Matched lengths';
eRule_DaisyChainStubLength : Result := 'Daisy Chain Stub Length';
eRule_PowerPlaneConnectStyle : Result := 'Power Plane Connect Style';
eRule_RoutingTopology : Result := 'Routing Topology';
eRule_RoutingPriority : Result := 'Routing Priority';
eRule_RoutingLayers : Result := 'Routing Layers';
eRule_RoutingCornerStyle : Result := 'Routing Corner Style';
eRule_RoutingViaStyle : Result := 'Routing Via Style';
eRule_PowerPlaneClearance : Result := 'Power Plane Clearance';
eRule_SolderMaskExpansion : Result := 'Solder Mask Expansion';
eRule_PasteMaskExpansion : Result := 'Paste Mask Expansion';
eRule_ShortCircuit : Result := 'Short Circuit';
eRule_BrokenNets : Result := 'Broken Nets';
eRule_ViasUnderSMD : Result := 'Vias Under SMD';
eRule_MaximumViaCount : Result := 'Maximum Via Count';
eRule_MinimumAnnularRing : Result := 'Minimum Annular Ring';
eRule_PolygonConnectStyle : Result := 'Polygon Connect Style';
eRule_AcuteAngle : Result := 'Acute Angle';
eRule_ConfinementConstraint : Result := 'Confinement Constraint';
eRule_SMDToCorner : Result := 'SMD to corner';
eRule_ComponentClearance : Result := 'Component Clearance';
eRule_ComponentRotations : Result := 'Component Rotations';
eRule_PermittedLayers : Result := 'Permitted Layers';
eRule_NetsToIgnore : Result := 'Nets To Ignore';
eRule_SignalStimulus : Result := 'Signal Stimulus';
eRule_Overshoot_FallingEdge : Result := 'Overshoot Falling Edge';
eRule_Overshoot_RisingEdge : Result := 'Overshoot Rising Edge';
eRule_Undershoot_FallingEdge : Result := 'Undershoot Falling Edge';
eRule_Undershoot_RisingEdge : Result := 'Undershoot Rising Edge';
eRule_MaxMinImpedance : Result := 'Max Min Impedance';
eRule_SignalTopValue : Result := 'Signal Top Value';
eRule_SignalBaseValue : Result := 'Signal Base Value';
eRule_FlightTime_RisingEdge : Result := 'Flight Time Rising Edge';
eRule_FlightTime_FallingEdge : Result := 'Flight Time Falling Edge';
eRule_LayerStack : Result := 'Layer Stack';
eRule_MaxSlope_RisingEdge : Result := 'Max Slope Rising Edge';
eRule_MaxSlope_FallingEdge : Result := 'Max Slope Falling Edge';
eRule_SupplyNets : Result := 'Supply Nets';
eRule_MaxMinHoleSize : Result := 'Max Min Hole Size';
eRule_TestPointStyle : Result := 'Test Point Style';
eRule_TestPointUsage : Result := 'Test Point Usage';
eRule_UnconnectedPin : Result := 'Unconnected Pin';
eRule_SMDToPlane : Result := 'SMD To Plane';
eRule_SMDNeckDown : Result := 'SMD Neck Down';
eRule_LayerPair : Result := 'Layer Pair';
eRule_FanoutControl : Result := 'FanOut Control';
End;
End;
{..............................................................................}
{..............................................................................}
Function ConvertLayerToString(L : TLayer) : String;
Begin
Result := Layer2String(L);
End;
{..............................................................................}
{..............................................................................}
Function ConvertObjectKindToString(O : TObjectId) : String;
Begin
Result := '';
Case O Of
eNoObject : Result := 'Any Object';
eArcObject : Result := 'Arc';
ePadObject : Result := 'Pad';
eViaObject : Result := 'Via';
eTrackObject : Result := 'Track';
eTextObject : Result := 'Text';
eFillObject : Result := 'Fill';
eConnectionObject : Result := 'Connection';
eNetObject : Result := 'Net';
eComponentObject : Result := 'Component';
ePolyObject : Result := 'Polygon';
eDimensionObject : Result := 'Dimension';
eCoordinateObject : Result := 'Coordinate';
eClassObject : Result := 'Class';
eRuleObject : Result := 'Rule';
eFromToObject : Result := 'FromTo';
eViolationObject : Result := 'Violation';
eEmbeddedObject : Result := 'Embedded';
eTraceObject : Result := 'Trace';
eSpareViaObject : Result := 'Spare Via';
eBoardObject : Result := 'Board';
eBoardOutlineObject : Result := 'Board Outline';
End;
End;
{..............................................................................}
{..............................................................................}
Function ConvertNetScopeToString(N : TNetScope) : String;
Begin
Result := '';
Case N Of
eNetScope_DifferentNetsOnly : Result := 'Different Nets only';
eNetScope_SameNetOnly : Result := 'Same Net only';
eNetScope_AnyNet : Result := 'Any Net';
End;
End;
{..............................................................................}
{..............................................................................}
Procedure SearchAndReportViolations;
Var
Board : IPCB_Board;
Iterator : IPCB_BoardIterator;
Violation : IPCB_Violation;
ViolationData : TStringList;
Rule : IPCB_Rule;
PCBObject : IPCB_Primitive;
S : TDynamicString;
Document : IServerDocument;
FileName : TPCBString;
Begin
// Retrieve the current board
Board := PCBServer.GetCurrentPCBBoard;
If Board = Nil then Exit;
// Create an iterator to look for violation objects only.
Iterator := Board.BoardIterator_Create;
Iterator.AddFilter_ObjectSet(MkSet(eViolationObject));
Iterator.AddFilter_LayerSet(AllLayers);
Iterator.AddFilter_Method(eProcessAll);
// Create a TSTringList object to store violation data.
ViolationData := TStringList.Create;
// search for violations
Violation := Iterator.FirstPCBObject;
While Violation <> Nil Do
Begin
ViolationData.Add('Violation Name: ' + Violation.Name + ' Description: ' + Violation.Description);
// Report design rule associated with the currently found violation object
Rule := Violation.Rule;
ViolationData.Add(' Rule Name: ' + Rule.Name + ', ' +
' Rule Kind: ' + ConvertRuleKindToString (Rule.RuleKind) + ', ' +
' NetScope : ' + ConvertNetScopeToString (Rule.NetScope) + ', ' +
' Rule Layer Kind : ' + ConvertRuleLayerKindToString(Rule.LayerKind) + ', ' +
' Scope 1 : ' + Rule.Scope1Expression + ', ' +
' Scope 2 : ' + Rule.Scope2Expression);
// Report first pcb object associated with a unary/binary design rule.
PCBObject := Violation.Primitive1;
//PCBObject.GetState_Kind always returns an eAnyObject, ObjectKind routine is not implemented!
ViolationData.Add(' ' +
' Object 1: ' + ConvertObjectKindToString(PCBObject.ObjectId) + ', ' +
' Layer 1: ' + ConvertLayerToString (PCBObject.Layer)
);
// Report second pcb object associated with a binary design rule.
// however there are unary and binary rules, thus, for unary rules,
// there will only be one object in violation associated with the violation
PCBObject := Violation.Primitive2;
If PCBObject <> Nil Then
Begin
ViolationData.Add(' ' +
' Object 2: ' + ConvertObjectKindToString(PCBObject.ObjectId) + ', '+
' Layer 2: ' + ConvertLayerToString (PCBObject.Layer)
);
End;
// insert a blank line..
ViolationData.Add('');
Violation := Iterator.NextPCBObject;
End;
Board.BoardIterator_Destroy(Iterator);
FileName := ChangeFileExt(Board.FileName,'.vio');
ViolationData.SaveToFile(Filename);
//Display violation details on a text document
If ViolationData.Count > 0 Then
Begin
// open and display the textfile
Document := Client.OpenDocument('Text', Filename);
If Document <> Nil Then
Client.ShowDocument(Document);
End;
ViolationData.Free;
End;
{..............................................................................}
{..............................................................................}
|
unit uWatermarkOptions;
interface
uses
Winapi.Windows,
System.SysUtils,
System.Classes,
System.Math,
System.Types,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
Vcl.StdCtrls,
Vcl.Samples.Spin,
Vcl.ExtCtrls,
Vcl.ComCtrls,
Dmitry.Graphics.Types,
Dmitry.Controls.Base,
Dmitry.Controls.WebLink,
Dmitry.Controls.WatermarkedEdit,
UnitDBFileDialogs,
UnitDBDeclare,
uDBGraphicTypes,
uConstants,
uMemory,
uDBForm,
uBitmapUtils,
uAssociations,
uSettings,
uDBEntities,
uImageLoader;
const
Settings_Watermark = 'Watermark settings';
type
TFrmWatermarkOptions = class(TDBForm)
BtnOk: TButton;
BtnCancel: TButton;
PcWatermarkType: TPageControl;
TsText: TTabSheet;
TsImage: TTabSheet;
LbBlocksX: TLabel;
LbTextColor: TLabel;
LbBlocksY: TLabel;
LbTextTransparency: TLabel;
LbWatermarkText: TLabel;
LbFontName: TLabel;
CbColor: TColorBox;
SeBlocksX: TSpinEdit;
SeBlocksY: TSpinEdit;
SeTextTransparency: TSpinEdit;
EdWatermarkText: TWatermarkedEdit;
CbFonts: TComboBox;
PnImageSettings: TPanel;
PbImage: TPaintBox;
LbInfo: TLabel;
CbKeepProportions: TCheckBox;
WlWatermarkedImage: TWebLink;
SeImageTransparency: TSpinEdit;
LbImageTransparency: TLabel;
procedure FormCreate(Sender: TObject);
procedure BtnOkClick(Sender: TObject);
procedure BtnCancelClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure PcWatermarkTypeChange(Sender: TObject);
procedure PbImageMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
procedure PbImageMouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
procedure PbImageMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure PbImagePaint(Sender: TObject);
procedure WlWatermarkedImageClick(Sender: TObject);
procedure SeImageTransparencyChange(Sender: TObject);
procedure FormDestroy(Sender: TObject);
private
{ Private declarations }
FWatermarkedFile: string;
WatermarkedImage: TBitmap;
FX: Integer;
FY: Integer;
ProportionsHeight: Integer;
ProportionsWidth: Integer;
FirstPoint: TPoint;
SecondPoint: TPoint;
MakingRect: Boolean;
ResizingRect: Boolean;
FxBottom: Boolean;
FxTop: Boolean;
FxCenter: Boolean;
FxLeft: Boolean;
FxRight: Boolean;
FBeginSecondPoint: TPoint;
FBeginFirstPoint: TPoint;
FBeginDragPoint: TPoint;
function BufferPointToImagePoint(P: TPoint): TPoint;
procedure LoadLanguage;
procedure SaveSettings;
procedure LoadSettings;
procedure LoadWatermarkImage(FileName: string);
procedure CheckSaveEnabled;
property XTop: Boolean read FxTop write FxTop;
property XLeft: Boolean read FxLeft write FxLeft;
property XBottom: Boolean read FxBottom write FxBottom;
property XRight: Boolean read FxRight write FxRight;
property XCenter: Boolean read FxCenter write FxCenter;
property BeginDragPoint: TPoint read FBeginDragPoint write FBeginDragPoint;
property BeginFirstPoint: TPoint read FBeginFirstPoint write FBeginFirstPoint;
property BeginSecondPoint: TPoint read FBeginSecondPoint write FBeginSecondPoint;
protected
{ Protected declarations }
function GetFormID : string; override;
public
{ Public declarations }
end;
procedure ShowWatermarkOptions;
implementation
procedure ShowWatermarkOptions;
var
FrmWatermarkOptions: TFrmWatermarkOptions;
begin
Application.CreateForm(TFrmWatermarkOptions, FrmWatermarkOptions);
try
FrmWatermarkOptions.ShowModal;
finally
FrmWatermarkOptions.Release;
end;
end;
function Znak(X: Extended): Extended;
begin
if X >= 0 then
Result := 1
else
Result := -1;
end;
{$R *.dfm}
procedure TFrmWatermarkOptions.BtnCancelClick(Sender: TObject);
begin
Close;
end;
procedure TFrmWatermarkOptions.BtnOkClick(Sender: TObject);
begin
SaveSettings;
Close;
end;
function TFrmWatermarkOptions.BufferPointToImagePoint(P: TPoint): TPoint;
begin
Result := P;
end;
procedure TFrmWatermarkOptions.CheckSaveEnabled;
begin
if PcWatermarkType.ActivePageIndex = Integer(WModeImage) then
BtnOk.Enabled := FWatermarkedFile <> '';
if PcWatermarkType.ActivePageIndex = Integer(WModeText) then
BtnOk.Enabled := True;
end;
procedure TFrmWatermarkOptions.FormCreate(Sender: TObject);
begin
Screen.Cursors[CUR_UPDOWN] := LoadCursor(HInstance, 'UPDOWN');
Screen.Cursors[CUR_LEFTRIGHT] := LoadCursor(HInstance, 'LEFTRIGHT');
Screen.Cursors[CUR_TOPRIGHT] := LoadCursor(HInstance, 'TOPLEFTBOTTOMRIGHT');
Screen.Cursors[CUR_RIGHTBOTTOM] := LoadCursor(HInstance, 'TOPRIGHTLEFTBOTTOM');
Screen.Cursors[CUR_HAND] := LoadCursor(HInstance, 'HAND');
Screen.Cursors[CUR_CROP] := LoadCursor(HInstance, 'CROP');
LoadLanguage;
ProportionsHeight := 1;
ProportionsWidth := 1;
FirstPoint := Point(PbImage.Width div 4, PbImage.Height div 4);
SecondPoint := Point(PbImage.Width div 4 * 3, PbImage.Height div 4 * 3);
MakingRect := False;
ResizingRect := False;
WatermarkedImage := TBitmap.Create;
CbFonts.Items := Screen.Fonts;
if CbFonts.Items.Count > 0 then
CbFonts.ItemIndex := 0;
LoadSettings;
end;
procedure TFrmWatermarkOptions.FormDestroy(Sender: TObject);
begin
F(WatermarkedImage);
end;
procedure TFrmWatermarkOptions.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key = VK_RETURN then
BtnOkClick(Sender);
if Key = VK_ESCAPE then
Close;
end;
function TFrmWatermarkOptions.GetFormID: string;
begin
Result := 'WatermarkOptions';
end;
procedure TFrmWatermarkOptions.LoadLanguage;
begin
BeginTranslate;
try
Caption := L('Watermark options');
LbWatermarkText.Caption := L('Watermark text') + ':';
EdWatermarkText.WatermarkText := L('Sample text');
LbBlocksX.Caption := L('Blocks horizontally') + ':';
LbBlocksY.Caption := L('Blocks vertically') + ':';
LbTextColor.Caption := L('Text color') + ':';
LbImageTransparency.Caption := L('Transparency');
LbTextTransparency.Caption := L('Transparency') + ':';
LbFontName.Caption := L('Font Name') + ':';
BtnOk.Caption := L('Ok');
BtnCancel.Caption := L('Cancel');
CbKeepProportions.Caption := L('Keep proportions');
TsText.Caption := L('Text');
TsImage.Caption := L('Image');
LbInfo.Caption := L('Use mouse to select area with watermark image');
WlWatermarkedImage.Text := L('Click to select watermark image');
finally
EndTranslate;
end;
end;
procedure TFrmWatermarkOptions.LoadSettings;
var
I: Integer;
FontName: string;
begin
PcWatermarkType.ActivePageIndex := AppSettings.ReadInteger(Settings_Watermark, 'Mode', Integer(WModeText));
EdWatermarkText.Text := AppSettings.ReadString(Settings_Watermark, 'Text', L('Sample text'));
SeBlocksX.Value := AppSettings.ReadInteger(Settings_Watermark, 'BlocksX', 3);
SeBlocksY.Value := AppSettings.ReadInteger(Settings_Watermark, 'BlocksY', 3);
CbColor.Selected := AppSettings.ReadInteger(Settings_Watermark, 'Color', clWhite);
SeTextTransparency.Value := AppSettings.ReadInteger(Settings_Watermark, 'TextTransparency', 25);
SeImageTransparency.Value := AppSettings.ReadInteger(Settings_Watermark, 'ImageTransparency', 50);
FontName := AnsiLowerCase(AppSettings.ReadString(Settings_Watermark, 'Font', 'Arial'));
for I := 0 to CbFonts.Items.Count - 1 do
if AnsiLowerCase(CbFonts.Items[I]) = FontName then
CbFonts.ItemIndex := I;
CbKeepProportions.Checked := AppSettings.ReadBool(Settings_Watermark, 'KeepProportions', True);
FirstPoint.X := Round(AppSettings.ReadInteger(Settings_Watermark, 'ImageStartX', Round(FirstPoint.X * 100 / PbImage.Width)) * PbImage.Width / 100);
FirstPoint.Y := Round(AppSettings.ReadInteger(Settings_Watermark, 'ImageStartY', Round(FirstPoint.Y * 100 / PbImage.Height)) * PbImage.Height / 100);
SecondPoint.X := Round(AppSettings.ReadInteger(Settings_Watermark, 'ImageEndX', Round(SecondPoint.X * 100 / PbImage.Width)) * PbImage.Width / 100);
SecondPoint.Y := Round(AppSettings.ReadInteger(Settings_Watermark, 'ImageEndY', Round(SecondPoint.Y * 100 / PbImage.Height)) * PbImage.Height / 100);
FWatermarkedFile := AppSettings.ReadString(Settings_Watermark, 'WatermarkImage');
LoadWatermarkImage(FWatermarkedFile);
end;
procedure TFrmWatermarkOptions.PbImageMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
const
De = 5;
var
P, ImagePoint, TopLeftPoint, RightBottomPoint: TPoint;
InImage: Boolean;
begin
FX := X;
FY := Y;
ImagePoint := BufferPointToImagePoint(Point(X, Y));
P.X := Min(PbImage.Width, Max(0, ImagePoint.X));
P.Y := Min(PbImage.Height, Max(0, ImagePoint.Y));
if (ImagePoint.X <> P.X) or (ImagePoint.Y <> P.Y) then
begin
PbImage.Cursor := crDefault;
Exit;
end;
ImagePoint.X := Min(PbImage.Width, Max(0, ImagePoint.X));
ImagePoint.Y := Min(PbImage.Height, Max(0, ImagePoint.Y));
TopLeftPoint.X := Min(SecondPoint.X, FirstPoint.X);
RightBottomPoint.X := Max(SecondPoint.X, FirstPoint.X);
TopLeftPoint.Y := Min(SecondPoint.Y, FirstPoint.Y);
RightBottomPoint.Y := Max(SecondPoint.Y, FirstPoint.Y);
InImage := PtInRect(Rect(TopLeftPoint.X - De, TopLeftPoint.Y - De, RightBottomPoint.X + De,
RightBottomPoint.Y + De), ImagePoint);
XTop := (Abs(ImagePoint.Y - TopLeftPoint.Y) <= De) and InImage;
XLeft := (Abs(ImagePoint.X - TopLeftPoint.X) <= De) and InImage;
XRight := (Abs(ImagePoint.X - RightBottomPoint.X) <= De) and InImage;
XBottom := (Abs(ImagePoint.Y - RightBottomPoint.Y) <= De) and InImage;
XCenter := PtInRect(Rect(TopLeftPoint.X + De, TopLeftPoint.Y + De, RightBottomPoint.X - De,
RightBottomPoint.Y - De), ImagePoint);
BeginDragPoint := ImagePoint;
BeginFirstPoint := FirstPoint;
BeginSecondPoint := SecondPoint;
if XTop or XLeft or XRight or XBottom or XCenter then
ResizingRect := True;
if not ResizingRect then
begin
FirstPoint := BufferPointToImagePoint(Point(X, Y));
SecondPoint := BufferPointToImagePoint(Point(X, Y));
MakingRect := True;
end;
end;
procedure TFrmWatermarkOptions.PbImageMouseMove(Sender: TObject;
Shift: TShiftState; X, Y: Integer);
var
P, ImagePoint, TopLeftPoint, RightBottomPoint, P1, P2, P11, P22: TPoint;
De, W, H, I, Ax, Ay, Ry: Integer;
Prop: Extended;
InImage: Boolean;
begin
if MakingRect then
begin
ImagePoint := BufferPointToImagePoint(Point(X, Y));
P.X := Min(PbImage.Width, Max(0, ImagePoint.X));
P.Y := Min(PbImage.Height, Max(0, ImagePoint.Y));
if CbKeepProportions.Checked then
begin
W := -(FirstPoint.X - P.X);
H := -(FirstPoint.Y - P.Y);
if W * H = 0 then
Exit;
if ProportionsHeight <> 0 then
Prop := ProportionsWidth / ProportionsHeight
else
Prop := 1;
if Abs(W / H) < Abs(Prop) then
begin
if W < 0 then
W := -Round(Abs(H) * (Prop))
else
W := Round(Abs(H) * (Prop));
if FirstPoint.X + W > PbImage.Width then
begin
W := PbImage.Width - FirstPoint.X;
H := Round(Znak(H) * W / Prop);
end;
if FirstPoint.X + W < 0 then
begin
W := -FirstPoint.X;
H := -Round(Znak(H) * W / Prop);
end;
SecondPoint := Point(FirstPoint.X + W, FirstPoint.Y + H);
end else
begin
if H < 0 then
H := -Round(Abs(W) * (1 / Prop))
else
H := Round(Abs(W) * (1 / Prop));
if FirstPoint.Y + H > PbImage.Height then
begin
H := PbImage.Height - FirstPoint.Y;
W := Round(Znak(W) * (H * Prop));
end;
if FirstPoint.Y + H < 0 then
begin
H := -FirstPoint.Y;
W := -Round(Znak(W) * (H * Prop));
end;
SecondPoint := Point(FirstPoint.X + W, FirstPoint.Y + H);
end;
end else
SecondPoint := P;
PbImage.Repaint;
end else
begin
ImagePoint := BufferPointToImagePoint(Point(X, Y));
ImagePoint.X := Min(PbImage.Width, Max(0, ImagePoint.X));
ImagePoint.Y := Min(PbImage.Height, Max(0, ImagePoint.Y));
P := BufferPointToImagePoint(Point(X, Y));
P.X := Min(PbImage.Width, Max(1, P.X));
P.Y := Min(PbImage.Height, Max(1, P.Y));
if CbKeepProportions.Checked then
begin
W := -(FirstPoint.X - P.X);
H := -(FirstPoint.Y - P.Y);
if W * H = 0 then
Exit;
if ProportionsHeight <> 0 then
Prop := ProportionsWidth / ProportionsHeight
else
Prop := 1;
if H = 0 then
Exit;
if Prop = 0 then
Exit;
if Abs(W / H) > Abs(Prop) then
begin
if W < 0 then
W := -Round(Abs(H) * (Prop))
else
W := Round(Abs(H) * (Prop));
P := Point(FirstPoint.X + W, FirstPoint.Y + H);
end else
begin
if H < 0 then
H := -Round(Abs(W) * (1 / Prop))
else
H := Round(Abs(W) * (1 / Prop));
P := Point(FirstPoint.X + W, FirstPoint.Y + H);
end;
end;
PbImage.Cursor := CUR_CROP;
De := 5;
if ResizingRect then
begin
if ResizingRect then
begin
if XCenter then
begin
W := ImagePoint.X - BeginDragPoint.X;
H := ImagePoint.Y - BeginDragPoint.Y;
W := Max(W, Max(-BeginFirstPoint.X, -BeginSecondPoint.X));
H := Max(H, Max(-BeginFirstPoint.Y, -BeginSecondPoint.Y));
W := Min(W, PbImage.Width - Max(BeginFirstPoint.X, BeginSecondPoint.X));
H := Min(H, PbImage.Height - Max(BeginFirstPoint.Y, BeginSecondPoint.Y));
FirstPoint := Point(BeginFirstPoint.X + W, BeginFirstPoint.Y + H);
SecondPoint := Point(BeginSecondPoint.X + W, BeginSecondPoint.Y + H);
end;
if not CbKeepProportions.Checked then
begin
if XLeft and not XRight then
begin
if FirstPoint.X > SecondPoint.X then
SecondPoint := Point(ImagePoint.X, SecondPoint.Y)
else
FirstPoint := Point(ImagePoint.X, FirstPoint.Y);
end;
if XTop and not XBottom then
begin
if FirstPoint.Y > SecondPoint.Y then
SecondPoint := Point(SecondPoint.X, ImagePoint.Y)
else
FirstPoint := Point(FirstPoint.X, ImagePoint.Y);
end;
if XRight then
begin
if FirstPoint.X < SecondPoint.X then
SecondPoint := Point(ImagePoint.X, SecondPoint.Y)
else
FirstPoint := Point(ImagePoint.X, FirstPoint.Y);
end;
if XBottom then
begin
if FirstPoint.Y < SecondPoint.Y then
SecondPoint := Point(SecondPoint.X, ImagePoint.Y)
else
FirstPoint := Point(FirstPoint.X, ImagePoint.Y);
end;
end else
begin
if ProportionsHeight <> 0 then
Prop := ProportionsWidth / ProportionsHeight
else
Prop := 1;
P1 := Point(Min(FirstPoint.X, SecondPoint.X), Min(FirstPoint.Y, SecondPoint.Y));
P2 := Point(Max(FirstPoint.X, SecondPoint.X), Max(FirstPoint.Y, SecondPoint.Y));
if XLeft and not XTop and not XRight then
begin
P11 := Point(ImagePoint.X, P1.Y);
P22 := Point(P2.X, P11.Y + Round((P2.X - P11.X) / Prop));
if P22.Y > PbImage.Height then
begin
P22 := Point(P2.X, PbImage.Height);
P11 := Point(P2.X - Round((PbImage.Height - P11.Y) * Prop), P1.Y);
end;
FirstPoint := P11;
SecondPoint := P22;
end;
if XTop and not XLeft and not XBottom then
begin
P11 := Point(P1.X, ImagePoint.Y);
P22 := Point(P11.X + Round((P2.Y - P11.Y) * Prop), P2.Y);
if P22.X > PbImage.Width then
begin
P22 := Point(PbImage.Width, P2.Y);
P11 := Point(P1.X, P2.Y - Round((PbImage.Width - P1.X) / Prop));
end;
FirstPoint := P11;
SecondPoint := P22;
end;
if XTop and XLeft and not XBottom then
begin
W := Abs(P2.X - ImagePoint.X);
H := Abs(P2.Y - ImagePoint.Y);
if Abs(W / H) > Abs(Prop) then
P11 := Point(ImagePoint.X, P2.Y - Round((P2.X - ImagePoint.X) / Prop))
else
P11 := Point(P2.X - Round((P2.Y - ImagePoint.Y) * Prop), ImagePoint.Y);
if P11.X < 0 then
P11 := Point(0, P2.Y - Round(P2.X / Prop));
if P11.Y < 0 then
P11 := Point(P2.X - Round(P2.Y * Prop), 0);
P22 := Point(P2.X, P2.Y);
FirstPoint := P11;
SecondPoint := P22;
end;
if XRight and not XBottom then
begin
P22 := Point(ImagePoint.X, P2.Y);
P11 := Point(P1.X, P22.Y - Round((P22.X - P1.X) / Prop));
if P11.Y < 0 then
begin
P22 := Point(P1.X + Round(P2.Y * Prop), P2.Y);
P11 := Point(P1.X, 0);
end;
FirstPoint := P11;
SecondPoint := P22;
end;
if XBottom and not XRight then
begin
P22 := Point(P2.X, ImagePoint.Y);
P11 := Point(P22.X - Round((P22.Y - P1.Y) * Prop), P1.Y);
if P11.X < 0 then
begin
P22 := Point(P2.X, P1.Y + Round(P2.X / Prop));
P11 := Point(0, P1.Y);
end;
FirstPoint := P11;
SecondPoint := P22;
end;
if XBottom and XRight then
begin
W := Abs(P1.X - ImagePoint.X);
H := Abs(P1.Y - ImagePoint.Y);
if Abs(W / H) > Abs(Prop) then
P22 := Point(ImagePoint.X, P1.Y - Round((P1.X - ImagePoint.X) / Prop))
else
P22 := Point(P1.X - Round((P1.Y - ImagePoint.Y) * Prop), ImagePoint.Y);
if P22.X > PbImage.Width then
P22 := Point(PbImage.Width, P1.Y + Round((PbImage.Width - P1.X) / Prop));
if P22.Y > PbImage.Height then
P22 := Point(P1.X + Round((PbImage.Height - P1.Y) * Prop), PbImage.Height);
P11 := Point(P1.X, P1.Y);
FirstPoint := P11;
SecondPoint := P22;
end;
end;
PbImage.Repaint;
end;
end else
begin
ImagePoint := BufferPointToImagePoint(Point(X, Y));
P.X := Min(PbImage.Width, Max(0, ImagePoint.X));
P.Y := Min(PbImage.Height, Max(0, ImagePoint.Y));
if (ImagePoint.X <> P.X) or (ImagePoint.Y <> P.Y) then
begin
PbImage.Cursor := CrDefault;
Exit;
end;
TopLeftPoint.X := Min(SecondPoint.X, FirstPoint.X);
RightBottomPoint.X := Max(SecondPoint.X, FirstPoint.X);
TopLeftPoint.Y := Min(SecondPoint.Y, FirstPoint.Y);
RightBottomPoint.Y := Max(SecondPoint.Y, FirstPoint.Y);
InImage := PtInRect(Rect(TopLeftPoint.X - De, TopLeftPoint.Y - De, RightBottomPoint.X + De,
RightBottomPoint.Y + De), ImagePoint);
XTop := (Abs(ImagePoint.Y - TopLeftPoint.Y) <= De) and InImage;
XLeft := (Abs(ImagePoint.X - TopLeftPoint.X) <= De) and InImage;
XRight := (Abs(ImagePoint.X - RightBottomPoint.X) <= De) and InImage;
XBottom := (Abs(ImagePoint.Y - RightBottomPoint.Y) <= De) and InImage;
XCenter := PtInRect(Rect(TopLeftPoint.X + De, TopLeftPoint.Y + De, RightBottomPoint.X - De,
RightBottomPoint.Y - De), ImagePoint);
BeginDragPoint := ImagePoint;
BeginFirstPoint := FirstPoint;
BeginSecondPoint := SecondPoint;
if (XTop and XLeft) or (XRight and XBottom) then
PbImage.Cursor := CUR_TOPRIGHT;
if PbImage.Cursor = CUR_CROP then
if (XBottom and XLeft) or (XRight and XTop) then
PbImage.Cursor := CUR_RIGHTBOTTOM;
if PbImage.Cursor = CUR_CROP then
if XRight or XLeft then
PbImage.Cursor := CUR_LEFTRIGHT;
if PbImage.Cursor = CUR_CROP then
if XTop or XBottom then
PbImage.Cursor := CUR_UPDOWN;
if (PbImage.Cursor = CUR_CROP) and XCenter then
PbImage.Cursor := CUR_HAND;
end;
end;
end;
procedure TFrmWatermarkOptions.PbImageMouseUp(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
P: TPoint;
W, H: Integer;
Prop: Extended;
begin
if MakingRect then
begin
P := BufferPointToImagePoint(Point(X, Y));
P.X := Min(PbImage.Width, Max(0, P.X));
P.Y := Min(PbImage.Height, Max(0, P.Y));
if CbKeepProportions.Checked then
begin
W := -(FirstPoint.X - P.X);
H := -(FirstPoint.Y - P.Y);
if W * H = 0 then
Exit;
if ProportionsHeight <> 0 then
Prop := ProportionsWidth / ProportionsHeight
else
Prop := 1;
if Abs(W / H) < Abs(Prop) then
begin
if W < 0 then
W := -Round(Abs(H) * (Prop))
else
W := Round(Abs(H) * (Prop));
if FirstPoint.X + W > PbImage.Width then
begin
W := PbImage.Width - FirstPoint.X;
H := Round(Znak(H) * W / Prop);
end;
if FirstPoint.X + W < 0 then
begin
W := -FirstPoint.X;
H := -Round(Znak(H) * W / Prop);
end;
SecondPoint := Point(FirstPoint.X + W, FirstPoint.Y + H);
end else
begin
if H < 0 then
H := -Round(Abs(W) * (1 / Prop))
else
H := Round(Abs(W) * (1 / Prop));
if FirstPoint.Y + H > PbImage.Height then
begin
H := PbImage.Height - FirstPoint.Y;
W := Round(Znak(W) * (H * Prop));
end;
if FirstPoint.Y + H < 0 then
begin
H := -FirstPoint.Y;
W := -Round(Znak(W) * (H * Prop));
end;
SecondPoint := Point(FirstPoint.X + W, FirstPoint.Y + H);
end;
end
else
SecondPoint := P;
end;
ResizingRect := False;
MakingRect := False;
end;
procedure TFrmWatermarkOptions.PbImagePaint(Sender: TObject);
var
B, WI: TBitmap;
I, J: Integer;
P: PARGB;
P1, P2: TPoint;
Transparency: Byte;
begin
B := TBitmap.Create;
try
B.SetSize(PbImage.Width, PbImage.Height);
B.PixelFormat := pf24Bit;
for I := 0 to B.Height - 1 do
begin
P := B.ScanLine[I];
for J := 0 to B.Width - 1 do
begin
if Odd((J div 10) + (I div 10)) then
begin
P[J].R := $80;
P[J].G := $80;
P[J].B := $80;
end else
begin
P[J].R := $AA;
P[J].G := $AA;
P[J].B := $AA;
end;
end;
end;
P1 := Point(Min(FirstPoint.X, SecondPoint.X), Min(FirstPoint.Y, SecondPoint.Y));
P2 := Point(Max(FirstPoint.X, SecondPoint.X), Max(FirstPoint.Y, SecondPoint.Y));
DrawTransparentColor(B, clRed, P1.X, P1.Y, P2.X - P1.X, P2.Y - P1.Y, $20);
B.Canvas.Pen.Color := $FFFFFF;
B.Canvas.Pen.Style := psDot;
B.Canvas.Brush.Style := bsClear;
B.Canvas.Rectangle(P1.X, P1.Y, P2.X, P2.Y);
B.Canvas.Pen.Color := 0;
B.Canvas.Rectangle(P1.X - 1, P1.Y - 1, P2.X + 1, P2.Y + 1);
WI := TBitmap.Create;
try
WI.PixelFormat := WatermarkedImage.PixelFormat;
DoResize(P2.X - P1.X, P2.Y - P1.Y, WatermarkedImage, WI);
Transparency := Round(SeImageTransparency.Value * 255 / 100);
if WI.PixelFormat = pf32bit then
DrawImageEx32To24Transparency(B, WI, P1.X, P1.Y, Transparency);
if WI.PixelFormat = pf24bit then
DrawImageExTransparency(B, WI, P1.X, P1.Y, Transparency);
finally
F(WI);
end;
PbImage.Canvas.Draw(0, 0, B);
finally
F(B);
end;
end;
procedure TFrmWatermarkOptions.PcWatermarkTypeChange(Sender: TObject);
begin
CheckSaveEnabled;
end;
procedure TFrmWatermarkOptions.SaveSettings;
var
P1, P2, SettingsStartPoint, SettingsEndPoint: TPoint;
begin
AppSettings.WriteString(Settings_Watermark, 'Text', EdWatermarkText.Text);
AppSettings.WriteInteger(Settings_Watermark, 'BlocksX', SeBlocksX.Value);
AppSettings.WriteInteger(Settings_Watermark, 'BlocksY', SeBlocksY.Value);
AppSettings.WriteInteger(Settings_Watermark, 'Color', CbColor.Selected);
AppSettings.WriteInteger(Settings_Watermark, 'TextTransparency', SeTextTransparency.Value);
AppSettings.WriteInteger(Settings_Watermark, 'ImageTransparency', SeImageTransparency.Value);
AppSettings.WriteString(Settings_Watermark, 'Font', CbFonts.Items[CbFonts.ItemIndex]);
AppSettings.WriteBool(Settings_Watermark, 'KeepProportions', CbKeepProportions.Checked);
P1 := Point(Min(FirstPoint.X, SecondPoint.X), Min(FirstPoint.Y, SecondPoint.Y));
P2 := Point(Max(FirstPoint.X, SecondPoint.X), Max(FirstPoint.Y, SecondPoint.Y));
SettingsStartPoint := Point(Round(100 * P1.X / PbImage.Width), Round(100 * P1.Y / PbImage.Height));
SettingsEndPoint := Point(Round(100 * P2.X / PbImage.Width), Round(100 * P2.Y / PbImage.Height));
AppSettings.WriteInteger(Settings_Watermark, 'ImageStartX', SettingsStartPoint.X);
AppSettings.WriteInteger(Settings_Watermark, 'ImageStartY', SettingsStartPoint.Y);
AppSettings.WriteInteger(Settings_Watermark, 'ImageEndX', SettingsEndPoint.X);
AppSettings.WriteInteger(Settings_Watermark, 'ImageEndY', SettingsEndPoint.Y);
AppSettings.WriteString(Settings_Watermark, 'WatermarkImage', FWatermarkedFile);
AppSettings.WriteInteger(Settings_Watermark, 'Mode', PcWatermarkType.ActivePageIndex);
AppSettings.ClearCache;
end;
procedure TFrmWatermarkOptions.SeImageTransparencyChange(Sender: TObject);
begin
PbImage.Repaint;
end;
procedure TFrmWatermarkOptions.WlWatermarkedImageClick(Sender: TObject);
var
OpenPictureDialog: DBOpenPictureDialog;
begin
OpenPictureDialog := DBOpenPictureDialog.Create;
try
OpenPictureDialog.Filter := TFileAssociations.Instance.FullFilter;
if OpenPictureDialog.Execute then
LoadWatermarkImage(OpenPictureDialog.FileName);
finally
F(OpenPictureDialog);
end;
end;
procedure TFrmWatermarkOptions.LoadWatermarkImage(FileName: string);
var
Info: TMediaItem;
FImageInfo: ILoadImageInfo;
Image: TBitmap;
begin
Info := TMediaItem.CreateFromFile(FileName);
try
if LoadImageFromPath(Info, -1, '', [ilfGraphic, ilfICCProfile, ilfPassword, ilfAskUserPassword, ilfUseCache], FImageInfo) then
begin
Image := FImageInfo.GenerateBitmap(Info, FImageInfo.GraphicWidth, FImageInfo.GraphicHeight, pf32Bit, clNone, [ilboFreeGraphic, ilboFullBitmap, ilboRotate, ilboApplyICCProfile]);
if Image <> nil then
begin
F(WatermarkedImage);
WatermarkedImage := Image;
ProportionsHeight := WatermarkedImage.Height;
ProportionsWidth := WatermarkedImage.Width;
PbImage.Refresh;
WlWatermarkedImage.Text := FileName;
FWatermarkedFile := FileName;
CheckSaveEnabled;
end;
end;
finally
F(Info);
end;
end;
end.
|
Program Squares15;
{Вариант 15b1 с ошибками - нет Constructor и Virtual}
Uses Graph, WinCrt, Square;
Type
TColoredSquare = object(TSquare)
Color: Integer;
Procedure Init(AX, AY:Integer; ASide: Word; AColor: Integer);
Function GetColor: Integer;
Procedure PutColor(AColor: Integer);
Procedure Show;
End;
{Реализация методов класса ColoredSquare}
Procedure TColoredSquare.Init(AX, AY:Integer; ASide: Word; AColor: Integer);
Begin
inherited Init(AX, AY, ASide);
Color:= AColor;
End;
Function TColoredSquare.GetColor: Integer;
Begin
GetColor:= Color;
End;
Procedure TColoredSquare.PutColor(AColor: Integer);
Begin
Hide;
Color:= AColor;
Show;
End;
Procedure TColoredSquare.Show;
Var currentcolor: Integer;
Begin
currentcolor:= Graph.GetColor;
Graph.SetColor(color);
inherited Show;
Graph.SetColor(currentcolor);
End;
Var gd,gm: Integer;
i: Word;
s: Array [1..15] of TColoredSquare;
Begin
gd:=Detect;
InitGraph(gd,gm,'');
ClearViewPort;
For i:=1 To 15 Do Begin
s[i].Init(1,1,3*i+20,i);
End;
While Keypressed Do ReadKey;
Randomize;
Repeat
i:=Random(15)+1;
s[i].MoveTo(Random(GetMaxX-s[i].GetSide),
Random(GetMaxY-s[i].GetSide));
Delay(10);
Until Keypressed;
ReadKey;
CloseGraph;
End.
|
unit docs.areas;
interface
uses
Horse,
Horse.GBSwagger;
procedure registry();
implementation
uses schemas.classes;
procedure registry();
begin
Swagger
.Path('produtor/{id_produtor}/areas')
.Tag('Áreas de Produção')
.GET('listar aras de produção de um produtor', 'listar aras de produção de um produtor')
.AddParamPath('id_produtor', 'id_produtor')
.Schema(SWAG_INTEGER)
.Required(true)
.&End
.AddResponse(200)
.Schema(TProductionArea)
.isArray(true)
.&End
.AddResponse(404, 'produtor não encontrada')
.Schema(TMessage)
.&End
.AddResponse(500, 'Internal Server Error')
.&End
.&End
.&End
.&End;
Swagger
.Path('produtor/{id_produtor}/areas/{id_area}/foto')
.Tag('Áreas de Produção')
.GET('listar foto de uma área de produção', 'listar foto de uma área de produção')
.AddParamPath('id_produtor', 'id_produtor')
.Schema(SWAG_INTEGER)
.required(true)
.&End
.AddParamPath('id_area', 'id_area')
.Schema(SWAG_INTEGER)
.required(true)
.&End
.AddResponse(200)
.Schema('image/png')
.&End
.AddResponse(404, 'produtor não encontrada | área não encontrada')
.Schema(TMessage)
.&End
.AddResponse(500, 'Internal Server Error')
.&End
.&End
.&End
.&End;
Swagger
.Path('produtor/{id_produtor}/areas')
.Tag('Áreas de Produção')
.Post('criar instiuição', 'criar uma nova instituição')
.AddparamPath('id_produtor', 'id_produtor')
.Schema(Swag_Integer)
.&end
.AddParamBody
.Schema(TProductionArea)
.&End
.AddResponse(201)
.Schema(TRegion)
.&End
.AddResponse(404, 'produtor não encontrado')
.Schema(TMessage)
.&End
.AddResponse(500, 'Internal Server Error')
.&End
.&End
.&End
.&End;
Swagger
.Path('produtor/{id_produtor}/areas/{id_area}')
.Tag('Áreas de Produção')
.Put('alterar uma a´rea de produção', 'alterar uma a´rea de produção')
.AddParamPath('id_produtor', 'id_produtor')
.Schema(SWAG_INTEGER)
.&end
.AddParamPath('id_area', 'id_area')
.Schema(SWAG_INTEGER)
.&end
.AddParamBody
.Schema(TProductionArea)
.&End
.AddResponse(200)
.Schema(TRegion)
.&End
.AddResponse(404, 'produtor não encontrada | área não encontrada')
.Schema(TMessage)
.&End
.AddResponse(500, 'Internal Server Error')
.&End
.&End
.&End
.&End;
Swagger
.Path('produtor/{id_produtor}/areas/{id_area}')
.Tag('Áreas de Produção')
.Delete('deletar area de produção', 'deletar area de produção')
.AddParamPath('id_produtor', 'id_produtor')
.Schema(SWAG_INTEGER)
.&end
.AddParamPath('id_area', 'id_area')
.Schema(SWAG_INTEGER)
.&end
.AddResponse(200, 'instituição deletada com sucesso')
.Schema(TMessage)
.&End
.AddResponse(404, 'produtor não encontrada | área não encontrada')
.Schema(TMessage)
.&End
.AddResponse(500, 'Internal Server Error')
.&End
.&End
.&End
.&End;
end;
end.
|
unit umain;
{$MODE Delphi}
interface
uses
{$IFDEF MSWINDOWS}
Windows,
{$ENDIF}
SysUtils, Classes, Controls, Forms, Dialogs, ExtCtrls,
GLScene, GLCadencer, GLMaterial, GLSimpleNavigation, GLLCLViewer,
GLWindowsFont, GLSLShader, GLObjects, GLFBORenderer, GLHUDObjects,
GLGeomObjects;
type
{ TGLDemoForm }
TGLDemoForm = class(TForm)
MainScene: TGLScene;
MainCamera: TGLCamera;
MainCadencer: TGLCadencer;
MainMaterialLibrary: TGLMaterialLibrary;
SceneObjects: TGLDummyCube;
MainViewer: TGLSceneViewer;
TestLight: TGLLightSource;
MultisampleFBO: TGLFBORenderer;
GLSLShader1: TGLSLShader;
GLSimpleNavigation1: TGLSimpleNavigation;
GLScreenQuad: TGLHUDSprite;
GLSphere1: TGLSphere;
GLTorus1: TGLTorus;
GLTorus2: TGLTorus;
GLCone1: TGLCone;
GLLines1: TGLLines;
FBOContainer: TGLDummyCube;
GLHUDText1: TGLHUDText;
GLWindowsBitmapFont1: TGLWindowsBitmapFont;
procedure FormCreate(Sender: TObject);
procedure MainCadencerProgress(Sender: TObject; const deltaTime,
newTime: Double);
procedure FormResize(Sender: TObject);
procedure GLSLShader1Initialize(Shader: TGLCustomGLSLShader);
procedure GLSLShader1Apply(Shader: TGLCustomGLSLShader);
end;
var
GLDemoForm: TGLDemoForm;
implementation
{$R *.lfm}
uses
OpenGL1x, GLState, LCLType,
GLKeyboard, GLMultisampleImage, VectorGeometry;
procedure TGLDemoForm.FormCreate(Sender: TObject);
begin
width := Screen.width;
height := Screen.height;
WindowState := wsMaximized;
with MainMaterialLibrary.TextureByName('MultisampledColor') do
begin
ImageClassName := 'TGLMultisampleImage';
TGLMultiSampleImage(Image).SamplesCount := 4;
end;
with MainMaterialLibrary.TextureByName('Depth') do
begin
ImageClassName := 'TGLMultisampleImage';
TGLMultiSampleImage(Image).SamplesCount := 4;
end;
GLSLShader1.Enabled := True;
GLHUDText1.Text := 'Press F1/F2 to switch multisampling' + #10#13 +
'F3/F4 - Warframe mode';
end;
procedure TGLDemoForm.MainCadencerProgress(Sender: TObject; const deltaTime,
newTime: Double);
begin
if isKeyDown(VK_F2) then
begin
FBOContainer.Visible := false;
GLScreenQuad.Visible := false;
SceneObjects.Visible := true;
end;
if isKeyDown(VK_F1) then
begin
FBOContainer.Visible := true;
GLScreenQuad.Visible := true;
SceneObjects.Visible := false;
end;
if isKeyDown(VK_F3) then
begin
GLTorus1.Material.PolygonMode := pmLines;
GLTorus2.Material.PolygonMode := pmLines;
GLCone1.Material.PolygonMode := pmLines;
end;
if isKeyDown(VK_F4) then
begin
GLTorus1.Material.PolygonMode := pmFill;
GLTorus2.Material.PolygonMode := pmFill;
GLCone1.Material.PolygonMode := pmFill;
end;
MainViewer.Invalidate;
end;
procedure TGLDemoForm.FormResize(Sender: TObject);
begin
MultisampleFBO.Width := MainViewer.Width;
MultisampleFBO.Height := MainViewer.Height;
GLScreenQuad.Width := MainViewer.Width;
GLScreenQuad.Height := MainViewer.Height;
GLScreenQuad.Position.SetPoint(
MainViewer.Width div 2,
MainViewer.Height div 2,
0);
end;
procedure TGLDemoForm.GLSLShader1Initialize(Shader: TGLCustomGLSLShader);
begin
if not GL_EXT_framebuffer_multisample then
begin
ShowMessage
('Sorry, your hardware do not support Multisampling');
Close;
end;
end;
procedure TGLDemoForm.GLSLShader1Apply(Shader: TGLCustomGLSLShader);
begin
with Shader, MainViewer do
begin
Param['TexUnit0'].AsTexture[0] :=
MainMaterialLibrary.TextureByName('MultisampledColor');
Param['ViewerSize'].AsVector2f := Vector2fMake(Width, Height);
end;
end;
end.
|
{*******************************************************************************
Title: T2Ti ERP
Description: Controller do lado Cliente relacionado à tabela [tribut_configura_of_gt]
The MIT License
Copyright: Copyright (C) 2014 T2Ti.COM
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
The author may be contacted at:
t2ti.com@gmail.com
@author Albert Eije (t2ti.com@gmail.com)
@version 2.0
*******************************************************************************}
unit TributConfiguraOfGtController;
{$MODE Delphi}
interface
uses
Classes, Dialogs, SysUtils, DB, LCLIntf, LCLType, LMessages, Forms, Controller,
TributConfiguraOfGtVO, ZDataset, VO;
type
TTributConfiguraOfGtController = class(TController)
private
public
class function Consulta(pFiltro: String; pPagina: String): TZQuery;
class function ConsultaLista(pFiltro: String): TListaTributConfiguraOfGtVO;
class function ConsultaObjeto(pFiltro: String): TTributConfiguraOfGtVO;
class procedure Insere(pObjeto: TTributConfiguraOfGtVO);
class function Altera(pObjeto: TTributConfiguraOfGtVO): Boolean;
class function Exclui(pId: Integer): Boolean;
class function ExcluiDetalhe(pId: Integer): Boolean;
end;
implementation
uses T2TiORM,
//
TributPisCodApuracaoVO, TributCofinsCodApuracaoVO, TributIpiDipiVO, TributIcmsUfVO,
TributOperacaoFiscalVO, TributGrupoTributarioVO;
var
ObjetoLocal: TTributConfiguraOfGtVO;
class function TTributConfiguraOfGtController.Consulta(pFiltro: String; pPagina: String): TZQuery;
begin
try
ObjetoLocal := TTributConfiguraOfGtVO.Create;
Result := TT2TiORM.Consultar(ObjetoLocal, pFiltro, pPagina);
finally
ObjetoLocal.Free;
end;
end;
class function TTributConfiguraOfGtController.ConsultaLista(pFiltro: String): TListaTributConfiguraOfGtVO;
begin
try
ObjetoLocal := TTributConfiguraOfGtVO.Create;
Result := TListaTributConfiguraOfGtVO(TT2TiORM.Consultar(ObjetoLocal, pFiltro, True));
finally
ObjetoLocal.Free;
end;
end;
class function TTributConfiguraOfGtController.ConsultaObjeto(pFiltro: String): TTributConfiguraOfGtVO;
var
Filtro: String;
begin
try
Result := TTributConfiguraOfGtVO.Create;
Result := TTributConfiguraOfGtVO(TT2TiORM.ConsultarUmObjeto(Result, pFiltro, True));
Filtro := 'ID_TRIBUT_CONFIGURA_OF_GT = ' + IntToStr(Result.Id);
// Objetos Vinculados
Result.TributOperacaoFiscalVO := TTributOperacaoFiscalVO(TT2TiORM.ConsultarUmObjeto(Result.TributOperacaoFiscalVO, 'ID='+IntToStr(Result.IdTributOperacaoFiscal), True));
Result.TributGrupoTributarioVO := TTributGrupoTributarioVO(TT2TiORM.ConsultarUmObjeto(Result.TributGrupoTributarioVO, 'ID='+IntToStr(Result.IdTributGrupoTributario), True));
Result.TributPisCodApuracaoVO := TTributPisCodApuracaoVO(TT2TiORM.ConsultarUmObjeto(Result.TributPisCodApuracaoVO, Filtro, True));
Result.TributCofinsCodApuracaoVO := TTributCofinsCodApuracaoVO(TT2TiORM.ConsultarUmObjeto(Result.TributCofinsCodApuracaoVO, Filtro, True));
Result.TributIpiDipiVO := TTributIpiDipiVO(TT2TiORM.ConsultarUmObjeto(Result.TributIpiDipiVO, Filtro, True));
// Listas
Result.ListaTributIcmsUfVO := TListaTributIcmsUfVO(TT2TiORM.Consultar(TTributIcmsUfVO.Create, Filtro, True));
finally
end;
end;
class procedure TTributConfiguraOfGtController.Insere(pObjeto: TTributConfiguraOfGtVO);
var
UltimoID: Integer;
begin
try
UltimoID := TT2TiORM.Inserir(pObjeto);
{ Pis }
pObjeto.TributPisCodApuracaoVO.IdTributConfiguraOfGt := UltimoID;
TT2TiORM.Inserir(pObjeto.TributPisCodApuracaoVO);
{ Cofins }
pObjeto.TributCofinsCodApuracaoVO.IdTributConfiguraOfGt := UltimoID;
TT2TiORM.Inserir(pObjeto.TributCofinsCodApuracaoVO);
{ Ipi }
pObjeto.TributIpiDipiVO.IdTributConfiguraOfGt := UltimoID;
TT2TiORM.Inserir(pObjeto.TributIpiDipiVO);
// Detalhes
/// EXERCICIO: Implemente os detalhes
Consulta('ID = ' + IntToStr(UltimoID), '0');
finally
end;
end;
class function TTributConfiguraOfGtController.Altera(pObjeto: TTributConfiguraOfGtVO): Boolean;
begin
try
Result := TT2TiORM.Alterar(pObjeto);
{ Pis }
Result := TT2TiORM.Alterar(pObjeto.TributPisCodApuracaoVO);
{ Cofins }
Result := TT2TiORM.Alterar(pObjeto.TributCofinsCodApuracaoVO);
{ Ipi }
Result := TT2TiORM.Alterar(pObjeto.TributIpiDipiVO);
// Detalhes
/// EXERCICIO: Implemente os detalhes
finally
end;
end;
class function TTributConfiguraOfGtController.Exclui(pId: Integer): Boolean;
var
ObjetoLocal: TTributConfiguraOfGtVO;
begin
try
ObjetoLocal := TTributConfiguraOfGtVO.Create;
ObjetoLocal.Id := pId;
Result := TT2TiORM.Excluir(ObjetoLocal);
finally
FreeAndNil(ObjetoLocal)
end;
end;
class function TTributConfiguraOfGtController.ExcluiDetalhe(pId: Integer): Boolean;
var
ObjetoLocal: TTributIcmsUfVO;
begin
try
ObjetoLocal := TTributIcmsUfVO.Create;
ObjetoLocal.Id := pId;
Result := TT2TiORM.Excluir(ObjetoLocal);
finally
FreeAndNil(ObjetoLocal)
end;
end;
initialization
Classes.RegisterClass(TTributConfiguraOfGtController);
finalization
Classes.UnRegisterClass(TTributConfiguraOfGtController);
end.
|
unit uneUtils;
{*******************************************************************************
* *
* Название модуля : *
* *
* uneUtils *
* *
* Назначение модуля : *
* *
* Централизованное хранение используемых в приложении процедур и функций. *
* *
* Copyright © Год 2005, Автор: Найдёнов Е.А *
* *
*******************************************************************************}
interface
uses
SysUtils, Classes, Windows, Forms, Dialogs, Controls, StdCtrls, IniFiles, Variants, cxGridDBTableView,
cxGridDBDataDefinitions, pFIBDataSet, Halcn6db, DB, DateUtils, uneTypes;
procedure SetFormPos ( const aOwner: TForm; var aForm: TForm );
procedure SetFirstZero ( var aDigit: String );
// procedure GetDateInv ( aDataSet: TpFIBDataSet; const aDateBeg, aDateEnd: TDate; const aDateCount: TCheckedBoxes );
// procedure GetSetUpInfo ( aDataSet: TpFIBDataSet; const aSetUpInfo: PSetUp );
procedure LogException ( const aFileName: TFileName );
procedure FreeAndNilPTR ( var aPointer: Pointer; const aPTRIsUntyped: Boolean = False );
// function GetValue ( const aStruct: TSection; const aValueName: String ): Variant;
function SortArray ( var aArray: TIntArray ): Boolean;
function ReadRecId ( const aDataContr: TcxGridDBDataController; const aKeyColumnIndex, aMultiColumnIndex: Integer; const aSelectedRecCount: Integer ): TIntArray;
function WriteRecId ( const aDataContr: TcxGridDBDataController; const aMultiColumnIndex: Integer; const aIdCheckedRec: TIntArray ): Boolean;
// function GetSpIndex ( const aOwner: TForm; const aMenuTag: Integer): Integer;
// function IsDateValid ( const aDateBeg, aDateEnd: String; const aDateCount: TCheckedBoxes ): Boolean ;
// function ReadIniFile ( var aIniFile: TIniFileInfo ): Boolean;
function MessageDlgRus ( const aCaption: TCaption; const aMsg: String; const aDlgType: TMsgDlgType; const aButtons: TMsgDlgButtons ): word;
function SelectRecords ( var aDBTableView: TcxGridDBTableView; const aColumnName: TcxGridDBColumn; const aSelectionKind: TSelectionType ): Integer;
function GetSelRecCount ( const aSelRecCount, aTotalRecCont: Integer ): TCheckedRecCount;
function CheckDBFStructure ( aSource: THalcyonDataSet; const aDBFFileName: String; aFields: array of TFieldRec; aErrorMsg: array of String; aHWND: HWND ): TImportCheckError;
function GetCheckedRecCount ( const aDataContr: TcxGridDBDataController; const aMultiColumnIndex: Integer ): Integer;
function GetMonthName(d : TDateTime) : shortstring;
implementation
procedure LogException ( const aFileName: TFileName );
{*******************************************************************************
* *
* Название процедуры : *
* *
* LogException *
* *
* Назначение процедуры : *
* *
* Процедура протоколирует ошибки, возникающие в приложении *
* *
* IN: *
* *
* aFileName - полный путь к файлу протокола. *
* *
*******************************************************************************}
var
m : word;
Buf : array[0..511] of char;
FStream : TFileStream;
begin
if FileExists( aFileName )
then
m := fmOpenReadWrite
else
m := fmCreate;
FStream := TFileStream.Create( aFileName, m );
FStream.Seek( 0, soFromEnd );
StrPCopy( Buf, DateTimeToStr(Now)+ '. ' );
ExceptionErrorMessage( ExceptObject, ExceptAddr, @Buf[ StrLen(Buf) ], SizeOf(Buf) - StrLen(Buf) );
StrCat( Buf, #13#10 );
FStream.WriteBuffer( Buf, StrLen(Buf) );
FStream.Free;
end; //End of procedure LogException
//function ReadIniFile( var aIniFile: TIniFileInfo ): Boolean;
{*******************************************************************************
* *
* Название функции : *
* *
* ReadIniFile *
* *
* Назначение функции : *
* *
* Организация корректного соединения с базой данных посредством считывания *
* настроек соединения из INI - файла на жёстком диске. *
* *
* IN: *
* *
* aIniFile - запись, содержащая информацию о содержимом файла настройки. *
* *
* OUT: *
* *
* aIniFile. *
* *
* RESULT: Boolean. *
* *
* Если соединение установленно, результат возвращаемый функцией - истина, *
* если нет - ложь. *
* *
*******************************************************************************}
{var
i, j : Integer;
IniFile : TIniFile;
FileName : String;
begin
try
Result := False;
IniFile := nil;
//Получаем путь + собственно имя файла настройки
FileName := ExtractFilePath( Application.ExeName ) + cINI_FILE_NAME;
//Проверяем существование файла настройки
if FileExists( FileName )
then begin
//Связываем файловую переменную с файлом настройки
IniFile := TIniFile.Create( FileName );
//Считываем настройки из файла конфигурации
with aIniFile
do
for i := Low( cSECTIONS.Keys ) to High( cSECTIONS.Keys ) do
begin
Sections.Keys[i].Name := cSECTIONS.Keys[i].Name;
Sections.Keys[i].Value := IniFile.ReadString( cSECTIONS.Name, cSECTIONS.Keys[i].Name, '' );
end;
//Освобождаем ресурсы
IniFile.Free;
Result := True;
end
else
MessageDlgRus( 'Ошибка', 'Файл настройки не найден', mtWarning, [mbOK] );
except
on EIniFileException do
begin
Result := False;
MessageDlg( 'Ошибка обработки INI-файла', mtError, [mbOK], 0 );
end;
end;
end;} //End of function ReadIniFile
procedure SetFormPos( const aOwner: TForm; var aForm: TForm );
{*******************************************************************************
* *
* Название процедуры : *
* *
* SetFormPos *
* *
* Назначение процедуры : *
* *
* Размещает дочернюю форму по центру относительно родительской формы. *
* *
* IN: *
* *
* aOwner - родительская форма. *
* aForm - дочерняя форма. *
* *
* OUT: *
* *
* aForm. *
* *
* RESULT: Новое положение дочерней формы относительно родительской. *
* *
*******************************************************************************}
begin
aForm.Left := aOwner.Left + Round( ( aOwner.Width - aForm.Width )/2 );
aForm.Top := aOwner.Top + Round( ( aOwner.Height - aForm.Height )/2 );
end; //End of procedure SetFormPos
//function GetValue( const aStruct: TSection; const aValueName: String ): Variant;
{*******************************************************************************
* *
* Название функции : *
* *
* GetValue *
* *
* Назначение функции : *
* *
* Возвращает значение элемента массива заданной структуры. *
* *
* IN: *
* *
* aStruct - структура. *
* aValueName - имя элемента структуры. *
* *
* OUT: *
* *
* Result : Variant. *
* *
* RESULT: Значение элемента массива. *
* *
*******************************************************************************}
{var
i : Integer;
begin
Result := Null;
for i := Low( aStruct.Keys ) to High( aStruct.Keys ) do
if aStruct.Keys[i].Name = aValueName
then begin
Result := aStruct.Keys[i].Value;
Break;
end;
end;} //End of function GetValue
function MessageDlgRus( const aCaption: TCaption; const aMsg: String; const aDlgType: TMsgDlgType; const aButtons: TMsgDlgButtons ): word;
{*******************************************************************************
* *
* Название функции : *
* *
* MessageDlgRus *
* *
* Назначение функции : *
* *
* Возвращает результат диалога. *
* *
* IN: *
* *
* aCaption - заголовок диалога. *
* aMsg - сообщение диалога. *
* aDlgType - тип диалога. *
* aButtons - набор кнопок для диалога. *
* *
* OUT: *
* *
* Result : Word. *
* *
* RESULT: Возвращает результат завершения диалога пользователем. *
* *
*******************************************************************************}
var
i : Integer;
MsgForm : TForm;
begin
if aButtons <> []
then begin
MsgForm := CreateMessageDialog( aMsg, aDlgType, aButtons );
MsgForm.Caption := aCaption;
for i := 0 to ( MsgForm.ComponentCount - 1 ) do
begin
if MsgForm.Components[i] is TButton
then begin
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = 'OK'
then
TButton( MsgForm.Components[i] ).Caption := 'Принять';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = 'CANCEL'
then
TButton( MsgForm.Components[i] ).Caption := 'Отменить';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&YES'
then
TButton( MsgForm.Components[i] ).Caption := 'Да';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&NO'
then
TButton( MsgForm.Components[i] ).Caption := 'Нет';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&ABORT'
then
TButton( MsgForm.Components[i] ).Caption := 'Отмена';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&RETRY'
then
TButton( MsgForm.Components[i] ).Caption := 'Повтор';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&IGNORE'
then
TButton( MsgForm.Components[i] ).Caption := 'Игнорировать';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&ALL'
then
TButton( MsgForm.Components[i] ).Caption := 'Всё';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = '&HELP'
then
TButton( MsgForm.Components[i] ).Caption := 'Помощь';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = 'N&O TO ALL'
then
TButton( MsgForm.Components[i] ).Caption := 'Нет для всех';
if UpperCase( TButton( MsgForm.Components[i] ).Caption ) = 'YES TO &ALL'
then
TButton( MsgForm.Components[i] ).Caption := 'Да для всех';
end;
end;
Result := MsgForm.ShowModal;
MsgForm.Free;
end
else begin
Result := 0;
end;
end; //End of Funtion MessageDlgRus
function SelectRecords( var aDBTableView: TcxGridDBTableView; const aColumnName: TcxGridDBColumn; const aSelectionKind: TSelectionType ): Integer;
{*******************************************************************************
* *
* Название функции : *
* *
* SelectRecords *
* *
* Назначение функции : *
* *
* Возвращает количество помеченных пользователем записей, в случае если спра-*
* вочник был вызван в режиме мультивыбора. *
* *
* IN: *
* *
* aColumnName - имя столбца, реализующего функциональность мультивыбора*
* aDBTableView - таблица, содержащая вышеуказанный столбец. *
* aSelectionKind - тип мультивыбора. *
* *
* OUT: *
* *
* Result : Integer. *
* *
* RESULT: Количество помеченных записей. *
* *
*******************************************************************************}
var
i : Integer;
CellValue : Variant;
begin
Result := 0;
case aSelectionKind of
stpSelectAll : begin
aDBTableView.BeginUpdate;
for i := 0 to ( aDBTableView.DataController.GetRecordCount - 1 ) do
begin
aDBTableView.DataController.Values[ i, aColumnName.Index ] := True;
Inc( Result );
end;
aDBTableView.EndUpdate;
end;
stpUnSelectAll: begin
aDBTableView.BeginUpdate;
for i := 0 to ( aDBTableView.DataController.GetRecordCount - 1 ) do
begin
aDBTableView.DataController.Values[ i, aColumnName.Index ] := False;
end;
aDBTableView.EndUpdate;
end;
stpInvert : begin
aDBTableView.BeginUpdate;
for i := 0 to ( aDBTableView.DataController.GetRecordCount - 1 ) do
begin
CellValue := aDBTableView.DataController.Values[ i, aColumnName.Index ];
if CellValue = Null
then
CellValue := False
else
CellValue := Boolean( CellValue );
if CellValue
then begin
aDBTableView.DataController.Values[ i, aColumnName.Index ] := False;
end
else begin
aDBTableView.DataController.Values[ i, aColumnName.Index ] := True;
Inc( Result );
end;
end;
aDBTableView.EndUpdate;
end;
end;
end; //End of function SelectRecords
function GetSpIndex( const aOwner: TForm; const aMenuTag: Integer): Integer;
{*******************************************************************************
* *
* Название функции : *
* *
* GetSpIndex *
* *
* Назначение функции : *
* *
* Возвращает индекс дочерней формы из списка дочерних окон родительской формы*
* *
* IN: *
* *
* aOwner - родительская форма. *
* aMenuTag - значение свойства Tag пункта меню. *
* *
* OUT: *
* *
* Result : Integer. *
* *
* RESULT: Индекс дочерней формы.Если дочерняя форма не найдена, функция воз - *
* вращает -1. (Идея: свойство Tag пункта меню, при клике на котором создаётся*
* экземпляр дочернего окна, должно быть равно значению свойства Tag класса, *
* от которого порождён данный экземпляр ) *
* *
*******************************************************************************}
var
i: Integer;
begin
Result := -1;
for i := 0 to ( aOwner.MDIChildCount - 1 ) do
begin
if aOwner.MDIChildren[i].Tag = aMenuTag
then begin
Result := i;
Break;
end
end;
end; // End of function GetSpIndex
function ReadRecId( const aDataContr: TcxGridDBDataController; const aKeyColumnIndex, aMultiColumnIndex: Integer; const aSelectedRecCount: Integer ): TIntArray;
{********************************************************************************
* *
* Название функции : *
* *
* ReadRecId *
* *
* Назначение функции : *
* *
* Запоминает идентификаторы помеченных записей в массив. *
* *
* IN: *
* *
* aDataContr - дата контроллер грида. *
* aKeyColumnIndex - индекс столбца, содержащего значения ключевого поля *
* aMultiColumnIndex - индекс столбца для мультивыбора. *
* aSelectedRecCount - количество помеченных записей. *
* *
* OUT: *
* *
* Result : TIntArray. *
* *
* RESULT: Массив идентификаторов помеченных записей. *
* *
********************************************************************************}
var
i, j : Integer;
CellValue : Variant;
begin
j := 0;
SetLength( Result, aSelectedRecCount );
for i := 0 to ( aDataContr.RecordCount - 1 ) do
begin
CellValue := aDataContr.Values[ i, aMultiColumnIndex ];
if CellValue = True
then begin
Result[j] := Integer( aDataContr.Values[ i, aKeyColumnIndex ] );
Inc(j);
end;
end;
end; //End of function ReadRecId
function WriteRecId( const aDataContr: TcxGridDBDataController; const aMultiColumnIndex: Integer; const aIdCheckedRec: TIntArray ): Boolean;
{********************************************************************************
* *
* Название функции : *
* *
* WriteRecId *
* *
* Назначение функции : *
* *
* Восстанавливает "галочки" для помеченных ранее записей. *
* *
* IN: *
* *
* aDataContr - дата контроллер грида. *
* aMultiColumnIndex - индекс столбца для мультивыбора. *
* aIdCheckedRec - массив идентификаторов помеченных записей. *
* *
* OUT: *
* *
* Result : Boolean. *
* *
* RESULT: Функция возвращает True, если для ВСЕХ помеченных записей "галочки" *
* успешно восстановлены, если же нет, тогда - False. *
* *
********************************************************************************}
var
i : Integer;
RecordIndex : Integer;
begin
Result := True;
for i := 0 to High( aIdCheckedRec ) do
begin
RecordIndex := aDataContr.FindRecordIndexByKey( aIdCheckedRec[i] );
if RecordIndex <> -1
then
aDataContr.Values[ RecordIndex, aMultiColumnIndex ] := True
else
Result := False;
end;
end; //End of function WriteRecId
function GetSelRecCount( const aSelRecCount, aTotalRecCont: Integer ): TCheckedRecCount;
{********************************************************************************
* *
* Название функции : *
* *
* GetSelRecCount *
* *
* Назначение функции : *
* *
* Возвращает значение перечислимого типа, показывающее кол-во помеченных запи-*
* сей относительно общего кол-ва записей в наборе данных. *
* *
* IN: *
* *
* aSelRecCount - кол-во помеченных записей. *
* aTotalRecCont - кол-во записей в наборе данных. *
* *
* OUT: *
* *
* Result : TCheckedRecCount. *
* *
* RESULT: значение перечислимого типа TCheckedRecCount. *
* *
********************************************************************************}
begin
if aSelRecCount = 0
then
Result := crcNone
else
if aSelRecCount = aTotalRecCont
then
Result := crcAll
else
Result := crcSome;
end; //End of function GetSelRecCount
function GetCheckedRecCount( const aDataContr: TcxGridDBDataController; const aMultiColumnIndex: Integer ): Integer;
{********************************************************************************
* *
* Название функции : *
* *
* GetCheckedRecCount *
* *
* Назначение функции : *
* *
* Пересчитывает кол-во помеченных записей. *
* *
* IN: *
* *
* aDataContr - дата контроллер грида. *
* aMultiColumnIndex - индекс столбца для мультивыбора. *
* *
* OUT: *
* *
* Result : Integer. *
* *
* RESULT: возвращает кол-во помеченных записей. *
* *
********************************************************************************}
var
i : Integer;
begin
Result := 0;
for i := 0 to ( aDataContr.RecordCount - 1 ) do
begin
if aDataContr.Values[ i, aMultiColumnIndex ] = True
then
Inc( Result );
end;
end; //End of function GetCheckedRecCount
//procedure GetDateInv( aDataSet: TpFIBDataSet; const aDateBeg, aDateEnd: TDate; const aDateCount: TCheckedBoxes );
{*******************************************************************************
* *
* Название процедуры : *
* *
* GetDateInv *
* *
* Назначение процедуры : *
* *
* Процедура возвращает множество дат регистрации налоговых накладных, удовле *
* творяющих некоторому интервалу времени. *
* Проверяет корректность значений дат начала и конца интервала времени и, *
* если значения не имеют смысла, тогда изменяет их на текущую дату. *
* *
* IN: *
* aDataSet - набор данных *
* aDateBeg - дата начала интервала времени. *
* aDateEnd - дата конца интервала времени. *
* aDateCount - кол-во используемыж дат. *
* *
* OUT: *
* *
* aDataSet *
* *
* RESULT: Новые значения дат регистрации налоговых накладных. *
* *
*******************************************************************************}
{begin
case aDateCount of
cbNone : begin
aDataSet.Close;
aDataSet.SQLs.SelectSQL.Clear;
aDataSet.SQLs.SelectSQL.Text := 'SELECT * FROM NDS_DT_DATES_SEL( Null, Null )ORDER BY DATE_INVOICE DESC';
aDataSet.Open;
end;
cbFrom : begin
aDataSet.Close;
aDataSet.SQLs.SelectSQL.Clear;
aDataSet.SQLs.SelectSQL.Text := 'SELECT * FROM NDS_DT_DATES_SEL(''' + DateToStr( aDateBeg ) + ''',Null )ORDER BY DATE_INVOICE DESC';
aDataSet.Open;
end;
cbTill : begin
aDataSet.Close;
aDataSet.SQLs.SelectSQL.Clear;
aDataSet.SQLs.SelectSQL.Text := 'SELECT * FROM NDS_DT_DATES_SEL( Null,''' + DateToStr( aDateEnd ) + ''')ORDER BY DATE_INVOICE DESC';
aDataSet.Open;
end;
cbBoth : begin
aDataSet.Close;
aDataSet.SQLs.SelectSQL.Clear;
aDataSet.SQLs.SelectSQL.Text := 'SELECT * FROM NDS_DT_DATES_SEL(''' + DateToStr( aDateBeg ) + ''',''' + DateToStr( aDateEnd ) + ''')ORDER BY DATE_INVOICE DESC';
aDataSet.Open;
end;
end;
end;} //End of procedure GetDateInv
//function IsDateValid( const aDateBeg, aDateEnd: String; const aDateCount: TCheckedBoxes ): Boolean ;
{*******************************************************************************
* *
* Название функции : *
* *
* IsDateValid *
* *
* Назначение функции : *
* *
* Проверяет корректность значений дат начала и конца интервала времени. *
* *
* IN: *
* aDateBeg - дата начала интервала времени. *
* aDateEnd - дата конца интервала времени. *
* aDateCount - кол-во используемыж дат. *
* *
* OUT: *
* *
* Result *
* *
* RESULT: Boolean. *
* *
*******************************************************************************}
{begin
case aDateCount of
cbNone : begin
Result := True;
end;
cbFrom : begin
if Trim( aDateBeg ) = ''
then
Result := False
else
Result := True;
end;
cbTill : begin
if Trim( aDateEnd ) = ''
then
Result := False
else
Result := True;
end;
cbBoth : begin
if ( ( Trim( aDateBeg ) <> '' ) and ( Trim( aDateEnd ) <> '' ) ) AND ( StrToDate( aDateBeg ) <= StrToDate( aDateEnd ) )
then
Result := True
else
Result := False;
end;
end;
end; //End of function IsDateValid
procedure GetSetUpInfo( aDataSet: TpFIBDataSet; const aSetUpInfo: PSetUp );}
{*******************************************************************************
* *
* Название процедуры : *
* *
* GetSetUpInfo *
* *
* Назначение процедуры : *
* *
* Возвращает значения системных настроек. *
* *
* IN: *
* aDataSet - набор данных. *
* aSetUpInfo - укзатель на структуру типа "вариантная запись". *
* *
* OUT: *
* *
* aSetUpInfo *
* *
* RESULT: Несмотря на то, что укзатель на структуру aSetUpInfo объявлен как *
* константа, значения полей структуры изменяются, а значение адреса, *
* который укзывает на эту структуру остаёться прежним. *
* *
*******************************************************************************}
{begin
aDataSet.Close;
aDataSet.SQLs.SelectSQL.Clear;
case Ord( PSetUp( aSetUpInfo )^.StProcName ) of
0 : begin
aDataSet.SQLs.SelectSQL.Text := PSetUp( aSetUpInfo )^.SQLText;
aDataSet.Open;
PSetup( aSetUpInfo )^.IdRecord := aDataSet.FBN('ID_RECORD' ).AsInteger;
PSetup( aSetUpInfo )^.DaysCount := aDataSet.FBN('DAYS_COUNT_BEFORE').AsInteger;
PSetup( aSetUpInfo )^.Pogreshnost := aDataSet.FBN('POGRESHNOST' ).AsCurrency;
end;
1 : begin
aDataSet.SQLs.SelectSQL.Text := PSetUp( aSetUpInfo )^.SQLText;
aDataSet.Open;
PSetup( aSetUpInfo )^.IdRecord := aDataSet.FBN('ID_RECORD' ).AsInteger;
PSetUp( aSetUpInfo )^.DateRate := aDataSet.FBN('DATE' ).AsDateTime;
PSetUp( aSetUpInfo )^.FixedRate := aDataSet.FBN('FIXED_RATE' ).AsFloat;
PSetUp( aSetUpInfo )^.UaTerrRate := aDataSet.FBN('UA_TERRITORY_RATE').AsFloat;
PSetUp( aSetUpInfo )^.ExportRate := aDataSet.FBN('EXPORT_RATE' ).AsFloat;
end;
2 : begin
aDataSet.SQLs.SelectSQL.Text := PSetUp( aSetUpInfo )^.SQLText;
aDataSet.Open;
PSetUp( aSetUpInfo )^.FixedRate := aDataSet.FBN('OUT_FIXED_RATE' ).AsFloat;
PSetUp( aSetUpInfo )^.UaTerrRate := aDataSet.FBN('OUT_UA_TERRITORY_RATE').AsFloat;
PSetUp( aSetUpInfo )^.ExportRate := aDataSet.FBN('OUT_EXPORT_RATE' ).AsFloat;
end;
end;
end; } //End of procedure GetSetUpInfo
function SortArray( var aArray: TIntArray ): Boolean;
{*******************************************************************************
* *
* Название функции : *
* *
* SortArray *
* *
* Назначение функции : *
* *
* Сортирует элементы динамического массива по возрастанию по методу Шелла. *
* *
* IN: *
* aArray - исходный динамический массив. *
* *
* OUT: *
* *
* Result: Boolean *
* *
* RESULT: Функция возвращает false, если был передан пустой массив . *
* *
*******************************************************************************}
var
i : Integer;
Step : Integer;
Temp : Integer;
StepDone : Boolean;
begin
if aArray <> nil
then begin
Step := High( aArray ) div 2;
repeat
repeat
StepDone := True;
for i := Low( aArray ) to ( High( aArray ) - Step ) do
begin
if aArray[i] > aArray[i + Step]
then begin
Temp := aArray[i];
aArray[i] := aArray[i + Step];
aArray[i + Step] := Temp;
StepDone := False;
end;
end;
until( StepDone );
Step := Step div 2;
until ( Step = 0 );
Result := True;
end
else
Result := False;
end; //End of function SortArray
function CheckDBFStructure( aSource: THalcyonDataSet; const aDBFFileName: String; aFields: array of TFieldRec; aErrorMsg: array of String; aHWND: HWND ): TImportCheckError;
{********************************************************************************
* *
* Название функции : *
* *
* CheckDBFStructure *
* *
* Назначение функции : *
* *
* Проверяет соответствие DBF-таблицы заданной структуре. *
* *
* IN: *
* aSource - НД, содержащий DBF-таблицу, подлежащую проверке. *
* aFields - список полей, по которым необходимо выполнить проверку. *
* aErrorMsg - список сообщений об ошибках, обнаруженных в ходе проверки*
* aDBFFileName - путь к DBF-файлу, содержащему таблицу для проверки. *
* *
* OUT: *
* *
* Result: TImportCheckError *
* *
* RESULT: Функция в результате проверки возвращает: *
* *
* ectNone - ошибки не были обнаружены. *
* ectFNUnknown - поле с заданным именем не найдено. *
* ectFTIcompatible - тип поля не соответствует ожидаемому. *
* ectParamsNotFound - параметры для проверки отсутствуют. *
* *
********************************************************************************}
var
i, n : Integer;
vField : TField;
begin
//Получаем структуру + данные из DBF-файла
if aSource.Active
then
aSource.Close;
aSource.TableName := aDBFFileName;
aSource.Open;
n := High( aFields );
//Проверяем: не пуст ли массив парметров полей?
if n = -1
then begin
Result := ectParamsNotFound;
Exit;
end
else begin
Result := ectNone;
end;
//Проверяем соответствие полей НД параметрам процедуры импорта
for i := Low( aFields ) to n
do begin
with aFields[i]
do begin
vField := aSource.FindField( FieldName );
//Проверяем имя поля
if vField = nil
then begin
Result := ectFNUnknown;
// MessageBox( aHWND, PChar( aErrorMsg[0] ), PChar( sMsgCaptionErr ), MB_OK or MB_ICONERROR );
Exit;
end
else
//Проверяем тип поля
if vField.DataType <> FieldType
then begin
Result := ectFTIcompatible;
// MessageBox( aHWND, PChar( aErrorMsg[1] ), PChar( sMsgCaptionErr ), MB_OK or MB_ICONERROR );
// Exit;
end;
end;
end;
end; //End of function CheckDBFStructure
procedure SetFirstZero( var aDigit: String );
{*******************************************************************************
* *
* Название процедуры : *
* *
* SetFirstZero *
* *
* Назначение процедуры : *
* *
* Добавляет к цифре управляющий ноль. *
* *
* IN: *
* *
* aDigit - цифра, подлежащая преобразованию. *
* *
*******************************************************************************}
begin
if StrToInt( aDigit ) < 10
then
aDigit := '0' + aDigit;
end; //End of procedure SetFirstZero
procedure FreeAndNilPTR( var aPointer: Pointer; const aPTRIsUntyped: Boolean = False );
{*******************************************************************************
* *
* Название процедуры : *
* *
* FreeAndNilPTR *
* *
* Назначение процедуры : *
* *
* Освобождает память, выделенную под указатель и удаляет ссылку на ее адрес. *
* *
* IN: *
* *
* aPointer - ссылка на указатель. *
* aPTRIsUntyped - признак, показывающий явл. ли указатель типизированным *
* или нет. *
* *
*******************************************************************************}
begin
if aPointer <> nil
then begin
if aPTRIsUntyped
then
FreeMemory( aPointer )
else
Dispose( aPointer );
aPointer := nil;
end;
end; //End of procedure FreeAndNilPTR
function GetMonthName(d : TDateTime) : Shortstring;
var
m : word;
begin
Result := '';
m := MonthOf(d);
case m of
1 : Result := 'Январь';
2 : Result := 'Февраль';
3 : Result := 'Март';
4 : Result := 'Апрель';
5 : Result := 'Май';
6 : Result := 'Июнь';
7 : Result := 'Июль';
8 : Result := 'Август';
9 : Result := 'Сентябрь';
10 : Result := 'Октябрь';
11 : Result := 'Ноябрь';
12 : Result := 'Декабрь';
end;
end;
end.
|
// ************************************************************************
// ***************************** CEF4Delphi *******************************
// ************************************************************************
//
// CEF4Delphi is based on DCEF3 which uses CEF3 to embed a chromium-based
// browser in Delphi applications.
//
// The original license of DCEF3 still applies to CEF4Delphi.
//
// For more information about CEF4Delphi visit :
// https://www.briskbard.com/index.php?lang=en&pageid=cef
//
// Copyright © 2017 Salvador Díaz Fau. All rights reserved.
//
// ************************************************************************
// ************ vvvv Original license and comments below vvvv *************
// ************************************************************************
(*
* Delphi Chromium Embedded 3
*
* Usage allowed under the restrictions of the Lesser GNU General Public License
* or alternatively the restrictions of the Mozilla Public License 1.1
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* Unit owner : Henri Gourvest <hgourvest@gmail.com>
* Web site : http://www.progdigy.com
* Repository : http://code.google.com/p/delphichromiumembedded/
* Group : http://groups.google.com/group/delphichromiumembedded
*
* Embarcadero Technologies, Inc is not permitted to use or redistribute
* this source code without explicit permission.
*
*)
unit uCEFClient;
{$IFNDEF CPUX64}
{$ALIGN ON}
{$MINENUMSIZE 4}
{$ENDIF}
{$I cef.inc}
interface
uses
{$IFDEF DELPHI16_UP}
WinApi.Windows,
{$ELSE}
Windows,
{$ENDIF}
uCEFBaseRefCounted, uCEFInterfaces, uCEFTypes;
type
TCefClientRef = class(TCefBaseRefCountedRef, ICefClient)
protected
function GetContextMenuHandler: ICefContextMenuHandler; virtual;
function GetDialogHandler: ICefDialogHandler; virtual;
function GetDisplayHandler: ICefDisplayHandler; virtual;
function GetDownloadHandler: ICefDownloadHandler; virtual;
function GetDragHandler: ICefDragHandler; virtual;
function GetFindHandler: ICefFindHandler; virtual;
function GetFocusHandler: ICefFocusHandler; virtual;
function GetGeolocationHandler: ICefGeolocationHandler; virtual;
function GetJsdialogHandler: ICefJsdialogHandler; virtual;
function GetKeyboardHandler: ICefKeyboardHandler; virtual;
function GetLifeSpanHandler: ICefLifeSpanHandler; virtual;
function GetRenderHandler: ICefRenderHandler; virtual;
function GetLoadHandler: ICefLoadHandler; virtual;
function GetRequestHandler: ICefRequestHandler; virtual;
function OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean; virtual;
public
class function UnWrap(data: Pointer): ICefClient;
end;
TCefClientOwn = class(TCefBaseRefCountedOwn, ICefClient)
protected
function GetContextMenuHandler: ICefContextMenuHandler; virtual;
function GetDialogHandler: ICefDialogHandler; virtual;
function GetDisplayHandler: ICefDisplayHandler; virtual;
function GetDownloadHandler: ICefDownloadHandler; virtual;
function GetDragHandler: ICefDragHandler; virtual;
function GetFindHandler: ICefFindHandler; virtual;
function GetFocusHandler: ICefFocusHandler; virtual;
function GetGeolocationHandler: ICefGeolocationHandler; virtual;
function GetJsdialogHandler: ICefJsdialogHandler; virtual;
function GetKeyboardHandler: ICefKeyboardHandler; virtual;
function GetLifeSpanHandler: ICefLifeSpanHandler; virtual;
function GetRenderHandler: ICefRenderHandler; virtual;
function GetLoadHandler: ICefLoadHandler; virtual;
function GetRequestHandler: ICefRequestHandler; virtual;
function OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean; virtual;
public
constructor Create; virtual;
end;
TCustomClientHandler = class(TCefClientOwn)
protected
FEvents : IChromiumEvents;
FLoadHandler : ICefLoadHandler;
FFocusHandler : ICefFocusHandler;
FContextMenuHandler : ICefContextMenuHandler;
FDialogHandler : ICefDialogHandler;
FKeyboardHandler : ICefKeyboardHandler;
FDisplayHandler : ICefDisplayHandler;
FDownloadHandler : ICefDownloadHandler;
FGeolocationHandler : ICefGeolocationHandler;
FJsDialogHandler : ICefJsDialogHandler;
FLifeSpanHandler : ICefLifeSpanHandler;
FRenderHandler : ICefRenderHandler;
FRequestHandler : ICefRequestHandler;
FDragHandler : ICefDragHandler;
FFindHandler : ICefFindHandler;
function GetContextMenuHandler: ICefContextMenuHandler; override;
function GetDialogHandler: ICefDialogHandler; override;
function GetDisplayHandler: ICefDisplayHandler; override;
function GetDownloadHandler: ICefDownloadHandler; override;
function GetDragHandler: ICefDragHandler; override;
function GetFindHandler: ICefFindHandler; override;
function GetFocusHandler: ICefFocusHandler; override;
function GetGeolocationHandler: ICefGeolocationHandler; override;
function GetJsdialogHandler: ICefJsdialogHandler; override;
function GetKeyboardHandler: ICefKeyboardHandler; override;
function GetLifeSpanHandler: ICefLifeSpanHandler; override;
function GetRenderHandler: ICefRenderHandler; override;
function GetLoadHandler: ICefLoadHandler; override;
function GetRequestHandler: ICefRequestHandler; override;
function OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean; override;
procedure InitializeInterfaces;
public
constructor Create(const events: IChromiumEvents;
aCreateLoadHandler, aCreateFocusHandler, aCreateContextMenuHandler, aCreateDialogHandler,
aCreateKeyboardHandler, aCreateDisplayHandler, aCreateDownloadHandler, aCreateGeolocationHandler,
aCreateJsDialogHandler, aCreateLifeSpanHandler, aCreateRenderHandler, aCreateRequestHandler,
aCreateDragHandler, aCreateFindHandler : boolean); reintroduce; virtual;
destructor Destroy; override;
end;
implementation
uses
{$IFDEF DELPHI16_UP}
System.SysUtils,
{$ELSE}
SysUtils,
{$ENDIF}
uCEFMiscFunctions, uCEFLibFunctions, uCEFProcessMessage, uCEFBrowser, uCEFLoadHandler,
uCEFFocusHandler, uCEFContextMenuHandler, uCEFDialogHandler, uCEFKeyboardHandler,
uCEFDisplayHandler, uCEFDownloadHandler, uCEFGeolocationHandler, uCEFJsDialogHandler,
uCEFLifeSpanHandler, uCEFRequestHandler, uCEFRenderHandler, uCEFDragHandler,
uCEFFindHandler, uCEFConstants, uCEFApplication;
// ******************************************************
// ****************** TCefClientRef *********************
// ******************************************************
class function TCefClientRef.UnWrap(data: Pointer): ICefClient;
begin
if (data <> nil) then
Result := Create(data) as ICefClient
else
Result := nil;
end;
function TCefClientRef.GetContextMenuHandler: ICefContextMenuHandler;
begin
Result := nil;
end;
function TCefClientRef.GetDialogHandler: ICefDialogHandler;
begin
Result := nil;
end;
function TCefClientRef.GetDisplayHandler: ICefDisplayHandler;
begin
Result := nil;
end;
function TCefClientRef.GetDownloadHandler: ICefDownloadHandler;
begin
Result := nil;
end;
function TCefClientRef.GetDragHandler: ICefDragHandler;
begin
Result := nil;
end;
function TCefClientRef.GetFindHandler: ICefFindHandler;
begin
Result := nil;
end;
function TCefClientRef.GetFocusHandler: ICefFocusHandler;
begin
Result := nil;
end;
function TCefClientRef.GetGeolocationHandler: ICefGeolocationHandler;
begin
Result := nil;
end;
function TCefClientRef.GetJsdialogHandler: ICefJsDialogHandler;
begin
Result := nil;
end;
function TCefClientRef.GetKeyboardHandler: ICefKeyboardHandler;
begin
Result := nil;
end;
function TCefClientRef.GetLifeSpanHandler: ICefLifeSpanHandler;
begin
Result := nil;
end;
function TCefClientRef.GetLoadHandler: ICefLoadHandler;
begin
Result := nil;
end;
function TCefClientRef.GetRenderHandler: ICefRenderHandler;
begin
Result := nil;
end;
function TCefClientRef.GetRequestHandler: ICefRequestHandler;
begin
Result := nil;
end;
function TCefClientRef.OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean;
begin
Result := False;
end;
// ******************************************************
// ****************** TCefClientOwn *********************
// ******************************************************
function cef_client_own_get_context_menu_handler(self: PCefClient): PCefContextMenuHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetContextMenuHandler);
end;
function cef_client_own_get_dialog_handler(self: PCefClient): PCefDialogHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetDialogHandler);
end;
function cef_client_own_get_display_handler(self: PCefClient): PCefDisplayHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetDisplayHandler);
end;
function cef_client_own_get_download_handler(self: PCefClient): PCefDownloadHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetDownloadHandler);
end;
function cef_client_own_get_drag_handler(self: PCefClient): PCefDragHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetDragHandler);
end;
function cef_client_own_get_find_handler(self: PCefClient): PCefFindHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetFindHandler);
end;
function cef_client_own_get_focus_handler(self: PCefClient): PCefFocusHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetFocusHandler);
end;
function cef_client_own_get_geolocation_handler(self: PCefClient): PCefGeolocationHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetGeolocationHandler);
end;
function cef_client_own_get_jsdialog_handler(self: PCefClient): PCefJsDialogHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetJsdialogHandler);
end;
function cef_client_own_get_keyboard_handler(self: PCefClient): PCefKeyboardHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetKeyboardHandler);
end;
function cef_client_own_get_life_span_handler(self: PCefClient): PCefLifeSpanHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetLifeSpanHandler);
end;
function cef_client_own_get_load_handler(self: PCefClient): PCefLoadHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetLoadHandler);
end;
function cef_client_own_get_get_render_handler(self: PCefClient): PCefRenderHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetRenderHandler);
end;
function cef_client_own_get_request_handler(self: PCefClient): PCefRequestHandler; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := CefGetData(GetRequestHandler);
end;
function cef_client_own_on_process_message_received(self: PCefClient; browser: PCefBrowser;
source_process: TCefProcessId; message: PCefProcessMessage): Integer; stdcall;
begin
with TCefClientOwn(CefGetObject(self)) do
Result := Ord(OnProcessMessageReceived(TCefBrowserRef.UnWrap(browser), source_process, TCefProcessMessageRef.UnWrap(message)));
end;
constructor TCefClientOwn.Create;
begin
inherited CreateData(SizeOf(TCefClient));
with PCefClient(FData)^ do
begin
get_context_menu_handler := cef_client_own_get_context_menu_handler;
get_dialog_handler := cef_client_own_get_dialog_handler;
get_display_handler := cef_client_own_get_display_handler;
get_download_handler := cef_client_own_get_download_handler;
get_drag_handler := cef_client_own_get_drag_handler;
get_find_handler := cef_client_own_get_find_handler;
get_focus_handler := cef_client_own_get_focus_handler;
get_geolocation_handler := cef_client_own_get_geolocation_handler;
get_jsdialog_handler := cef_client_own_get_jsdialog_handler;
get_keyboard_handler := cef_client_own_get_keyboard_handler;
get_life_span_handler := cef_client_own_get_life_span_handler;
get_load_handler := cef_client_own_get_load_handler;
get_render_handler := cef_client_own_get_get_render_handler;
get_request_handler := cef_client_own_get_request_handler;
on_process_message_received := cef_client_own_on_process_message_received;
end;
end;
function TCefClientOwn.GetContextMenuHandler: ICefContextMenuHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetDialogHandler: ICefDialogHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetDisplayHandler: ICefDisplayHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetDownloadHandler: ICefDownloadHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetDragHandler: ICefDragHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetFindHandler: ICefFindHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetFocusHandler: ICefFocusHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetGeolocationHandler: ICefGeolocationHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetJsdialogHandler: ICefJsDialogHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetKeyboardHandler: ICefKeyboardHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetLifeSpanHandler: ICefLifeSpanHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetLoadHandler: ICefLoadHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetRenderHandler: ICefRenderHandler;
begin
Result := nil;
end;
function TCefClientOwn.GetRequestHandler: ICefRequestHandler;
begin
Result := nil;
end;
function TCefClientOwn.OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean;
begin
Result := False;
end;
// ******************************************************
// *************** TCustomClientHandler *****************
// ******************************************************
constructor TCustomClientHandler.Create(const events : IChromiumEvents;
aCreateLoadHandler : boolean;
aCreateFocusHandler : boolean;
aCreateContextMenuHandler : boolean;
aCreateDialogHandler : boolean;
aCreateKeyboardHandler : boolean;
aCreateDisplayHandler : boolean;
aCreateDownloadHandler : boolean;
aCreateGeolocationHandler : boolean;
aCreateJsDialogHandler : boolean;
aCreateLifeSpanHandler : boolean;
aCreateRenderHandler : boolean;
aCreateRequestHandler : boolean;
aCreateDragHandler : boolean;
aCreateFindHandler : boolean);
begin
inherited Create;
InitializeInterfaces;
FEvents := events;
if (FEvents <> nil) then
begin
if aCreateLoadHandler then FLoadHandler := TCustomLoadHandler.Create(FEvents);
if aCreateFocusHandler then FFocusHandler := TCustomFocusHandler.Create(FEvents);
if aCreateContextMenuHandler then FContextMenuHandler := TCustomContextMenuHandler.Create(FEvents);
if aCreateDialogHandler then FDialogHandler := TCustomDialogHandler.Create(FEvents);
if aCreateKeyboardHandler then FKeyboardHandler := TCustomKeyboardHandler.Create(FEvents);
if aCreateDisplayHandler then FDisplayHandler := TCustomDisplayHandler.Create(FEvents);
if aCreateDownloadHandler then FDownloadHandler := TCustomDownloadHandler.Create(FEvents);
if aCreateGeolocationHandler then FGeolocationHandler := TCustomGeolocationHandler.Create(FEvents);
if aCreateJsDialogHandler then FJsDialogHandler := TCustomJsDialogHandler.Create(FEvents);
if aCreateLifeSpanHandler then FLifeSpanHandler := TCustomLifeSpanHandler.Create(FEvents);
if aCreateRenderHandler then FRenderHandler := TCustomRenderHandler.Create(FEvents);
if aCreateRequestHandler then FRequestHandler := TCustomRequestHandler.Create(FEvents);
if aCreateDragHandler then FDragHandler := TCustomDragHandler.Create(FEvents);
if aCreateFindHandler then FFindHandler := TCustomFindHandler.Create(FEvents);
end;
end;
destructor TCustomClientHandler.Destroy;
begin
InitializeInterfaces;
inherited Destroy;
end;
procedure TCustomClientHandler.InitializeInterfaces;
begin
FLoadHandler := nil;
FFocusHandler := nil;
FContextMenuHandler := nil;
FDialogHandler := nil;
FKeyboardHandler := nil;
FDisplayHandler := nil;
FDownloadHandler := nil;
FGeolocationHandler := nil;
FJsDialogHandler := nil;
FLifeSpanHandler := nil;
FRequestHandler := nil;
FRenderHandler := nil;
FDragHandler := nil;
FFindHandler := nil;
FEvents := nil;
end;
function TCustomClientHandler.GetContextMenuHandler: ICefContextMenuHandler;
begin
Result := FContextMenuHandler;
end;
function TCustomClientHandler.GetDialogHandler: ICefDialogHandler;
begin
Result := FDialogHandler;
end;
function TCustomClientHandler.GetDisplayHandler: ICefDisplayHandler;
begin
Result := FDisplayHandler;
end;
function TCustomClientHandler.GetDownloadHandler: ICefDownloadHandler;
begin
Result := FDownloadHandler;
end;
function TCustomClientHandler.GetDragHandler: ICefDragHandler;
begin
Result := FDragHandler;
end;
function TCustomClientHandler.GetFindHandler: ICefFindHandler;
begin
Result := FFindHandler;
end;
function TCustomClientHandler.GetFocusHandler: ICefFocusHandler;
begin
Result := FFocusHandler;
end;
function TCustomClientHandler.GetGeolocationHandler: ICefGeolocationHandler;
begin
Result := FGeolocationHandler;
end;
function TCustomClientHandler.GetJsdialogHandler: ICefJsDialogHandler;
begin
Result := FJsDialogHandler;
end;
function TCustomClientHandler.GetKeyboardHandler: ICefKeyboardHandler;
begin
Result := FKeyboardHandler;
end;
function TCustomClientHandler.GetLifeSpanHandler: ICefLifeSpanHandler;
begin
Result := FLifeSpanHandler;
end;
function TCustomClientHandler.GetLoadHandler: ICefLoadHandler;
begin
Result := FLoadHandler;
end;
function TCustomClientHandler.GetRenderHandler: ICefRenderHandler;
begin
Result := FRenderHandler;
end;
function TCustomClientHandler.GetRequestHandler: ICefRequestHandler;
begin
Result := FRequestHandler;
end;
function TCustomClientHandler.OnProcessMessageReceived(const browser: ICefBrowser; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean;
begin
if (FEvents <> nil) then
Result := FEvents.doOnProcessMessageReceived(browser, sourceProcess, message)
else
Result := False;
end;
end.
|
unit Mycat.SQLEngine;
interface
uses
System.Classes, System.SysUtils, System.Generics.Collections,
MyCat.Net.CrossSocket.Base,
Mycat.BackEnd.Mysql.CrossSocket.Handler, Mycat.BackEnd.DataSource;
type
TEngineCtx = class;
IAllJobFinishedListener = interface
procedure OnAllJobFinished(Ctx: TEngineCtx);
end;
ISQLJobHandler = interface
procedure OnHeader(DataNode: string; Header: Tbytes; Fields: TList<Tbytes>);
function OnRowData(DataNode: string; RowData: Tbytes): Boolean;
procedure Finished(DataNode: string; Failed: Boolean; ErrorMsg: String);
end;
TSQLJob = class(TThread, IResponseHandler)
private
FSql: string;
FdataNodeOrDatabase: string;
FConnection: ICrossConnection;
FJobHandler: ISQLJobHandler;
FCtx: TEngineCtx;
FDS: TPhysicalDataSource;
FID: Integer;
Finished: Boolean;
end;
TBatchSQLJob = class
private
FRunningJobs: TThreadDictionary<Integer, TSQLJob>;
protected
{ protected declarations }
public
{ public declarations }
published
{ published declarations }
end;
// public class {
//
// private ConcurrentHashMap<Integer, SQLJob> = new ConcurrentHashMap<Integer, SQLJob>();
// private ConcurrentLinkedQueue<SQLJob> waitingJobs = new ConcurrentLinkedQueue<SQLJob>();
// private volatile boolean noMoreJobInput = false;
// /*
// *
// * parallExecute: 是否可以并行执行
// * */
// public void addJob(SQLJob newJob, boolean parallExecute) {
//
// if (parallExecute) {
// runJob(newJob);
// } else {
// waitingJobs.offer(newJob);
// if (runningJobs.isEmpty()) {
// SQLJob job = waitingJobs.poll();
// if (job != null) {
// runJob(job);
// }
// }
// }
// }
// //设置批量任务已经不会在添加任务了。
// public void setNoMoreJobInput(boolean noMoreJobInput) {
// this.noMoreJobInput = noMoreJobInput;
// }
// //执行任务
// private void runJob(SQLJob newJob) {
// // EngineCtx.LOGGER.info("run job " + newJob);
// runningJobs.put(newJob.getId(), newJob);
// MycatServer.getInstance().getBusinessExecutor().execute(newJob);
// }
// //单个的任务执行完毕。 等待任务列表中有任务， 继续执行下一个任务。
// //返回： 是否所有的任务执行完毕。
// public boolean jobFinished(SQLJob sqlJob) {
// if (EngineCtx.LOGGER.isDebugEnabled()) {
// EngineCtx.LOGGER.info("job finished " + sqlJob);
// }
// runningJobs.remove(sqlJob.getId());
// SQLJob job = waitingJobs.poll();
// if (job != null) {
// runJob(job);
// return false;
// } else {
// if (noMoreJobInput) {
// return runningJobs.isEmpty() && waitingJobs.isEmpty();
// } else {
// return false;
// }
// }
//
// }
// }
//
// 任务的进行的调用，
// 向mysqlClient 写数据。
TEngineCtx = class
private
// private final BatchSQLJob bachJob;
// private AtomicInteger jobId = new AtomicInteger(0);
// AtomicInteger packetId = new AtomicInteger(0);
// private final NonBlockingSession session;
// private AtomicBoolean finished = new AtomicBoolean(false);
// private AllJobFinishedListener allJobFinishedListener;
// private AtomicBoolean headerWrited = new AtomicBoolean();
// private final ReentrantLock writeLock = new ReentrantLock();
// private volatile boolean hasError = false;
// private volatile RouteResultset rrs;
// private volatile boolean isStreamOutputResult = true; //是否流式输出。
protected
{ protected declarations }
public
{ public declarations }
published
{ published declarations }
end;
// public class EngineCtx {
// public static final Logger LOGGER = LoggerFactory.getLogger(ConfFileHandler.class);
// public EngineCtx(NonBlockingSession session) {
// this.bachJob = new BatchSQLJob();
// this.session = session;
// }
//
// public boolean getIsStreamOutputResult(){
// return isStreamOutputResult;
// }
// public void setIsStreamOutputResult(boolean isStreamOutputResult){
// this. isStreamOutputResult = isStreamOutputResult;
// }
// public byte incPackageId() {
// return (byte) packetId.incrementAndGet();
// }
// /*
// * 将sql 发送到所有的dataNodes分片
// * 顺序执行
// * */
// public void executeNativeSQLSequnceJob(String[] dataNodes, String sql,
// SQLJobHandler jobHandler) {
// for (String dataNode : dataNodes) {
// SQLJob job = new SQLJob(jobId.incrementAndGet(), sql, dataNode,
// jobHandler, this);
// bachJob.addJob(job, false);
//
// }
// }
//
// public ReentrantLock getWriteLock() {
// return writeLock;
// }
// /*
// * 所有任务完成的回调
// * */
// public void setAllJobFinishedListener(
// AllJobFinishedListener allJobFinishedListener) {
// this.allJobFinishedListener = allJobFinishedListener;
// }
// /*
// * 将sql 发送到所有的dataNodes分片
// * 可以并行执行
// * */
// public void executeNativeSQLParallJob(String[] dataNodes, String sql,
// SQLJobHandler jobHandler) {
// for (String dataNode : dataNodes) {
// SQLJob job = new SQLJob(jobId.incrementAndGet(), sql, dataNode,
// jobHandler, this);
// bachJob.addJob(job, true);
//
// }
// }
//
// /**
// * set no more jobs created
// */
// public void endJobInput() {
// bachJob.setNoMoreJobInput(true);
// }
// //a 表和 b表的字段的信息合并在一块。
// //向mysql client 输出。
// public void writeHeader(List<byte[]> afields, List<byte[]> bfields) {
// if (headerWrited.compareAndSet(false, true)) {
// try {
// writeLock.lock();
// // write new header
// ResultSetHeaderPacket headerPkg = new ResultSetHeaderPacket();
// headerPkg.fieldCount = afields.size() +bfields.size()-1;
// headerPkg.packetId = incPackageId();
// LOGGER.debug("packge id " + headerPkg.packetId);
// ServerConnection sc = session.getSource();
// ByteBuffer buf = headerPkg.write(sc.allocate(), sc, true);
// // wirte a fields
// for (byte[] field : afields) {
// field[3] = incPackageId();
// buf = sc.writeToBuffer(field, buf);
// }
// // write b field
// for (int i=1;i<bfields.size();i++) {
// byte[] bfield = bfields.get(i);
// bfield[3] = incPackageId();
// buf = sc.writeToBuffer(bfield, buf);
// }
// // write field eof
// EOFPacket eofPckg = new EOFPacket();
// eofPckg.packetId = incPackageId();
// buf = eofPckg.write(buf, sc, true);
// sc.write(buf);
// //LOGGER.info("header outputed ,packgId:" + eofPckg.packetId);
// } finally {
// writeLock.unlock();
// }
// }
//
// }
//
// public void writeHeader(List<byte[]> afields) {
// if (headerWrited.compareAndSet(false, true)) {
// try {
// writeLock.lock();
// // write new header
// ResultSetHeaderPacket headerPkg = new ResultSetHeaderPacket();
// headerPkg.fieldCount = afields.size();// -1;
// headerPkg.packetId = incPackageId();
// LOGGER.debug("packge id " + headerPkg.packetId);
// ServerConnection sc = session.getSource();
// ByteBuffer buf = headerPkg.write(sc.allocate(), sc, true);
// // wirte a fields
// for (byte[] field : afields) {
// field[3] = incPackageId();
// buf = sc.writeToBuffer(field, buf);
// }
//
// // write field eof
// EOFPacket eofPckg = new EOFPacket();
// eofPckg.packetId = incPackageId();
// buf = eofPckg.write(buf, sc, true);
// sc.write(buf);
// //LOGGER.info("header outputed ,packgId:" + eofPckg.packetId);
// } finally {
// writeLock.unlock();
// }
// }
//
// }
//
// public void writeRow(RowDataPacket rowDataPkg) {
// ServerConnection sc = session.getSource();
// try {
// writeLock.lock();
// rowDataPkg.packetId = incPackageId();
// // 输出完整的 记录到客户端
// ByteBuffer buf = rowDataPkg.write(sc.allocate(), sc, true);
// sc.write(buf);
// //LOGGER.info("write row ,packgId:" + rowDataPkg.packetId);
// } finally {
// writeLock.unlock();
// }
// }
//
// public void writeEof() {
// ServerConnection sc = session.getSource();
// EOFPacket eofPckg = new EOFPacket();
// eofPckg.packetId = incPackageId();
// ByteBuffer buf = eofPckg.write(sc.allocate(), sc, false);
// sc.write(buf);
// LOGGER.info("write eof ,packgId:" + eofPckg.packetId);
// }
//
//
// public NonBlockingSession getSession() {
// return session;
// }
// //单个sqlJob任务完成之后调用的。
// //全部任务完成之后 回调allJobFinishedListener 这个函数。
// public void onJobFinished(SQLJob sqlJob) {
//
// boolean allFinished = bachJob.jobFinished(sqlJob);
// if (allFinished && finished.compareAndSet(false, true)) {
// if(!hasError){
// LOGGER.info("all job finished for front connection: "
// + session.getSource());
// allJobFinishedListener.onAllJobFinished(this);
// }else{
// LOGGER.info("all job finished with error for front connection: "
// + session.getSource());
// }
// }
//
// }
//
// public boolean isHasError() {
// return hasError;
// }
//
// public void setHasError(boolean hasError) {
// this.hasError = hasError;
// }
//
// public void setRouteResultset(RouteResultset rrs){
// this.rrs = rrs;
// }
// }
implementation
end.
|
{$M 20000,0,30000}
Program Xwing_Cheat_Utility; { Version 2.0 par D. MORCELLET }
uses Dos,Crt,Drivers,XUtils,Menus,Windows,Desktop,Config,Misc,TxtFonts;
CONST
{ Nombre maximal de pilotes g‚r‚s }
MaxPilot=30;
{ Nombre de missions pour chaque StarFighter }
NbMissions : ARRAY[0..3] of Byte = (6,6,6,6);
{ Correspondances entre les num‚ros et indices de missions }
C : ARRAY[0..4,0..24] of Byte = (
(0,1,2,3,4,5,6,7,8,9,10,11,12,12,12,12,12,12,12,12,12,12,12,12,12),
(0,1,2,3,4,5,6,7,8,9,10,11,12,12,12,12,12,12,12,12,12,12,12,12,14),
(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,14,14,14,14,14,14,14,14,14,14),
(0,1,2,3,4,5,5,6,7,7,8,9,10,11,11,12,13,14,15,15,16,17,18,19,20),
(0,1,2,3,4,5,6,7,8,9,10,10,11,12,13,13,14,15,16,16,17,18,19,19,20));
VAR
{ Nombre de StarFighters diff‚rents : Xwing,Awing,Bwing,Ywing }
StarFighters : Byte;
{ Nombre de tours install‚s : Tour I,II,III,IV ... }
NbTours : Byte;
{ Variable File associ‚e au fichier pilote }
PilotFile : FILE OF Byte;
{ Chemin d'accŠs des fichiers pilote }
XWingPATH : DirStr;
{ Nom du fichier pilote sans l'extension .PLT }
PilotName : NameStr;
{ Nom d'accŠs complet du fichier pilote }
PilotFilePATH : PathStr;
{ Indique la pr‚sence de modules suppl‚mentaires }
BwingModule,ImperialPursuitModule : Boolean;
{ Indique la pr‚sence d'un pilote en m‚moire }
aPilotIsLoaded : Boolean;
{ Indique si le pilote a ‚t‚ modifi‚ ou non }
Modified : Boolean;
{ Variables utilis‚e dans les fenˆtres }
{ Indique un vaisseau : 0=Xwing,1=Ywing,2=Awing,3=Bwing }
Craft : Byte;
{ Indique un niveau : entre 0 et 8 (pour l'entraŒnement)}
Level : Byte;
{ Indique un Tour : 0=Tour I,1=Tour II,... }
Tour : Byte;
{ Indique un num‚ro de mission }
Mission : Byte;
{ Liste des pilotes du r‚pertoire XWingPATH }
Pilots : ARRAY[1..MaxPilot] of NameStr;
{ Liste des descriptifs de pilote, ex : Commander X (Flight Officer) }
PilotStrs : ARRAY[1..MaxPilot] of String[40];
{ Nombre de pilotes dans le r‚pertoire XWingPATH }
NbrOfPilots : Byte;
DestroyedCrafts,CapturedCrafts : LongInt;
{ Indique le score pour la mission d‚sign‚e par Mission,Craft
et si elle a ‚t‚ remplie ou non ... }
procedure MissionScoreWindowContent; FAR;
VAR WhereCompleted : Word;
Where : Value;
Score : LongInt;
begin
{ Calcul de l'adresse voulue... }
WhereCompleted:=SuccessfulHistoricMissions+Mission+Craft*16;
{ Calcul du score }
Where:=HistoricScores;Where.Offset:=Where.Offset+Mission*4+Craft*64;
Score:=ReadFromMemory(Where);
{ Affichage : Mission (not) completed ; xxxx points }
Write(' Mission ');IF NOT (T[WhereCompleted]=1) THEN Write('not ');
Write('completed ; ',Score,' points');
end;
procedure TODVictoriesContent; FAR;
VAR C : ARRAY[0..20] of String[25];
Victories : ARRAY[0..20,KindOfVictories] of Word;
i,j : Byte;
Where : Value;
Begin
j:=0;
for i:=0 to 23 do
if CraftsNames[i+1]<>'' THEN BEGIN
C[j]:=CraftsNames[i+1];
Where:=TODCraftsDestroyed;Where.Offset:=Where.Offset+i*2;
Victories[j,Destroyed]:=ReadFromMemory(Where);
Where:=TODCraftsCaptured;Where.Offset:=Where.Offset+i*2;
Victories[j,Captured]:=ReadFromMemory(Where);
Inc(j);
END;
for i:=0 to 20 do begin
gotoxy(2,i+1);Write(C[i]);gotoxy(30,i+1);Write(Victories[i,Destroyed]);
gotoxy(40,i+1);Write(Victories[i,Captured]);
end;
end;
PROCEDURE PrintTODVictories;
VAR
WhereDestroyed,WhereCaptured : Value;
i : Byte;
BEGIN
DestroyedCrafts:=0;CapturedCrafts:=0;
for i:=0 to 23 do begin
TextColor(LightCyan);Gotoxy(5+35*(i div 12),3+(i mod 12));
WhereDestroyed:=TODCraftsDestroyed;WhereCaptured:=TODCraftsCaptured;
WhereDestroyed.offset:=WhereDestroyed.offset+2*i;
WhereCaptured.Offset:=WhereCaptured.offset+2*i;
DestroyedCrafts:=DestroyedCrafts+ReadFromMemory(WhereDestroyed);
CapturedCrafts:=CapturedCrafts+REadFromMemory(WhereCaptured);
IF CraftsNames[i+1]<>'' THEN BEGIN
Write(CraftsNames[i+1]);TextColor(White);
WriteLn(' : ',ReadFromMemory(WhereDestroyed),' (',ReadFromMemory(WhereCaptured),')');
END;
end;
END;
procedure OperationScoreWindowContent; FAR;
VAR Where : Value;
begin
{ Calcul d'adresse }
Where:=TODScores;Where.Offset:=Where.Offset+Tour*100+Mission*4;
{ Affichage du score }
TextColor(White);Write(' Current score : ',ReadFromMemory(Where));
end;
{ Renvoie une chaŒne d‚crivant le tour en cours (None,Tour I,Tour II...) }
FUNCTION CurrentTour : STRING;
BEGIN
IF T[CurrentTOD]<NbTours THEN CurrentTour:=TourName[T[CurrentTOD]]
ELSE CurrentTour:='None';
END;
{ Affiche les caract‚ristiques du pilote en m‚moire }
procedure PilotContent; FAR;
begin
{ Fixe la couleur White, mˆme si la fenˆtre est en arriŠre plan }
TextColor(White);
{ Nom et grade du pilote }
WriteLn(' ',Ranks[T[Rank]],' ',PilotName,' (',StatusNames[T[Status]],')');
{ Exp‚rience en Tour of Duty }
WriteLn(' TOD Points : ',ReadFromMemory(TODXP));
{ Exp‚rience en Missions Historiques }
WriteLn(' Historic Missions : ',ReadFromMemory(HistoricXP),' (',GetHistoricRank,')');
{ Indique le Tour en cours }
Write(' Current Tour of Duty : ',CurrentTour);
end;
procedure PilotLogContent; FAR;
VAR i,j : Integer;
Where : Value;
Key : Char;
begin
{ Page 1 : Proving Grounds }
WriteLn;
TextColor(LightRed);WriteLn(' Proving Ground ...');TextColor(White);
for i:=0 to StarFighters-1 do begin
Write(' '+StarFightersNames[i+1]+' : you have completed level ',T[$86+i]);
Where:=TrainingScores;Where.Offset:=Where.Offset+i*4;
WriteLn(' with a (best) score of ',ReadFromMemory(Where));
end;
Key:=ReadKey;ClrScr;
{ Page 2 : Historic Combat Missions }
WriteLn;TextColor(LightRed);WriteLn(' Historic Combat Missions');
for i:=0 to StarFighters-1 do begin
TextColor(LightCyan);gotoxy(4,4+i*3);
Write(StarFightersNames[i+1],' ( Completed : ');
for j:=0 to NbMissions[i]-1 do if T[$220+i*16+j]=1 THEN Write(j+1,' ');
WriteLn(')');TextColor(White);
for j:=0 to NbMissions[i]-1 do begin
Where:=HistoricScores;Where.Offset:=Where.Offset+i*64+j*4;
gotoxy((j mod 3)*23+5,5+i*3+(j div 3));;
write(' Mission ',j+1,' : ',ReadFromMemory(Where));
end;
end;
Key:=readKey;ClrScr;
{ Page 3 : TOD Victories }
PrintTODVictories;
gotoxy(3,2);TextColor(LightRed);Write('TOD Crafts Destroyed (Captured) : ');
TextColor(White);Writeln(destroyedCrafts,' (',capturedCrafts,')');
gotoxy(3,16);TextColor(LightRed);Write('TOD Surface Victories : ');
TextColor(White);Write(ReadFromMemory(TODSurfaceVictories));
Key:=ReadKey;ClrScr;
TextColor(LightRed);gotoxy(2,2);Write('TOD Laser Fired : ');
TextColor(White);Write(ReadFromMemory(TODLaserFired));
TextColor(LightCyan);gotoxy(5,3);Write('TOD Laser Craft Hits : ');
TextColor(White);Write(ReadFromMemory(TODLaserCraftHits),' (');
IF ReadFromMemory(TODLaserFired)>0 THEN
Write(Trunc(ReadFromMemory(TODLaserCraftHits)/ReadFromMemory(TODLaserFired)*100),'%)')
ELSE Write('Undefined %)');
TextColor(LightCyan);gotoxy(5,4);Write('TOD Laser Ground Hits : ');
TextColor(White);Write(ReadFromMemory(TODLaserGroundHits),' (');
IF ReadFromMemory(TODLaserFired)>0 THEN
Write(Trunc(ReadFromMemory(TODLaserGroundHits)/ReadFromMemory(TODLaserFired)*100),'%)')
ELSE Write('Undefined %)');
TextColor(LightRed);gotoxy(2,6);Write('TOD Homing Projectiles Fired : ');
TextColor(White);Write(ReadFromMemory(TODHomingProjFired));
TextColor(LightCyan);gotoxy(5,7);Write('TOD Homing Projectiles Craft Hits : ');
TextColor(White);Write(ReadFromMemory(TODHPCraftHits),' (');
IF ReadFromMemory(TODHomingProjFired)>0 THEN
Write(Trunc(ReadFromMemory(TODHPCraftHits)/ReadFromMemory(TODHomingProjFired)*100),'%)')
ELSE Write('Undefined %)');
TextColor(LightCyan);gotoxy(5,8);Write('TOD Homing Projectiles Ground Hits : ');
TextColor(White);Write(ReadFromMemory(TODHPGroundHits),' (');
IF ReadFromMemory(TODHomingProjFired)>0 THEN
Write(Trunc(ReadFromMemory(TODHPGroundHits)/ReadFromMemory(TODHomingProjFired)*100),'%)')
ELSE Write('Undefined %)');
TextColor(LightRed);gotoxy(2,10);Write('TOD Crafts Lost : ');
TextColor(White);Write(ReadFromMemory(TODCraftsLost));
FOR i:=0 to NbTours-1 do begin
gotoxy(2,12+i);
IF (i<3) OR ((i=3) AND ImperialPursuitModule)
OR ((i=4) AND BwingModule) THEN BEGIN
if T[TourOperation+i]=0 THEN Write('No operation completed for ',TourName[i])
else write('You completed ',T[TourOperation+i],' operation(s) in ',TourName[i]);
END
ELSE write(TourName[i],' not available');
END;
Key:=ReadKey;
end;
PROCEDURE RecognizeConfig;
BEGIN
{ Valeurs standard de NbTours et Starfighters pour Xwing seul }
NbTours:= 3;
StarFighters:=3;
{ Reconnaissance des modules suppl‚mentaires ... }
{ B-wing }
BwingModule:=NOT (FSearch('TOUR5.XID',XwingPath)='');
{ Imperial Pursuit - Tour IV }
ImperialPursuitModule:=NOT (FSearch('TOUR4.XID',XwingPath)='');
{ Modification des valeurs standard en fonction des modules ... }
{ Imperial Pursuit }
IF ImperialPursuitModule THEN NbTours:=4;
{ B-wing }
IF BwingModule THEN BEGIN
NbTours:=5;Inc(StarFighters);
END;
{ Et c'est tout ... }
END;
FUNCTION PilotStr(aPilotName : String ) : String;
VAR Rank,Status : Byte;
BEGIN
Assign(PilotFile,XWingPATH+'\'+aPilotName+'.PLT');Reset(PilotFile);
Read(PilotFile,Rank,Rank,Status,Rank);
Close(PilotFile);
PilotStr:=Ranks[Rank]+' '+aPilotName+' ('+StatusNames[status]+')';
END;
PROCEDURE ReadPilots;
VAR DirInfo : SearchRec;
BEGIN
EmptyMenu('pilotsmenu');
NbrOfPilots:=0;
FindFirst(XWingPATH+'\*.PLT',AnyFile,DirInfo);
IF DosError>0 THEN Erreur('No pilot found... Create one with X-wing !');
WHILE DosError=0 DO BEGIN
Delete(DirInfo.Name,Pos('.PLT',DirInfo.Name),4);
Inc(NbrOfPilots);Pilots[NbrOfPilots]:=DirInfo.Name;
AddArticle(GetMenu('pilotsmenu')^,PilotStr(DirInfo.Name),White,True,' ');
FindNext(DirInfo);
END;
END;
procedure Init;
VAR aFile : TEXT;
aStr : STRING;
begin
{ Loads the CONFIG file XWCU.CFG ... }
UseConfigFile('XWCU.CFG');
REPEAT
aStr:=FindNextInfo;
IF aStr>'' THEN BEGIN
IF Variable(aStr)='XWINGPATH' THEN XWingPath:=Valeur(aStr);
END;
UNTIL aStr='';
CloseConfigFile;
IF FSearch('XWING.EXE',XWingPATH)='' THEN
Erreur('The X-wing program path set by the Config file is invalid');
{ ReconnaŒt la pr‚sence de modules suppl‚mentaires }
RecognizeConfig;
{ Inits variables }
aPilotIsLoaded:=False;Modified:=False;
{ Inits Text Mode }
InitTextMode(CO80,Magenta);
end;
procedure LoadData;
VAR aMenu : Menu; aWindow : WindowType;
i : Byte;
aFile : TEXT;
begin
{ Reads MENUS.DOC menus definitions }
Assign(aFile,'MENUS.DOC');
IF FSearch('MENUS.DOC',GetCurrentPath)=''
THEN Erreur('Unable to find Menus definition file MENUS.DOC...');
Reset(aFile);
FOR i:=1 to NbrOfMenus DO BEGIN
ReadMenuFromFile(aFile,aMenu);NewMenu(aMenu);
END;
Close(aFile);
{ Reads WINDOWS.DOC windows defintions }
Assign(aFile,'WINDOWS.DOC');
IF FSearch('WINDOWS.DOC',GetCurrentPath)=''
THEN Erreur('Unable to find Windows definition file WINDOWS.DOC...');
Reset(aFile);
FOR i:=1 to NbrOfWindows DO BEGIN
ReadWindowFromFile(aFile,aWindow);NewWindow(aWindow);
END;
Close(aFile);
SetContentProc('Pilot',PilotContent);
SetContentProc('PilotLog',PilotLogContent);
SetContentProc('Score1',MissionScoreWindowContent);
SetContentProc('Score2',OperationScoreWindowContent);
SetContentProc('Kills',TODVictoriesContent);
IF ImperialPursuitModule THEN BEGIN
EnableArticle('tours',4);
END;
IF BwingModule THEN BEGIN
EnableArticle('tours',5);
EnableArticle('crafts',4);
END;
end;
procedure DisplayPilot;
BEGIN
IF Modified THEN SetWindowTitle('Pilot','Pilot in memory (modified)')
ELSE SetWindowTitle('Pilot','Pilot in memory');
Show('Pilot');
END;
procedure WritePilot;
VAR i : Integer;
begin
Rewrite(PilotFile);
for i:=0 to FileLength do write(PilotFile,T[i]);
Close(PilotFile);
Modified:=False;
end;
FUNCTION AskForSave : Boolean;
VAR anAnswer : Char;
BEGIN
Show('AskSave');
REPEAT
Write(' Save your modified pilot before closing (y/n) ? ');
anAnswer:=ReadKey;anAnswer:=UPCASE(anAnswer);WriteLn(anAnswer);
UNTIL (anAnswer='Y') OR (anAnswer='N');
IF anAnswer='Y' then AskForSave:=True ELSE AskForSave:=False;
Hide('AskSave');
END;
PROCEDURE ClosePilot;
VAR i : Byte;
BEGIN
IF aPilotIsLoaded THEN BEGIN
IF Modified=True THEN IF AskForSave=True THEN WritePilot;
Hide('Pilot');
for i:=2 to 4 do DisableArticle('main',i);
SetArticleIntitule('main',1,'Load a pilot {.PLT file)');
END;
Modified:=False;
END;
FUNCTION AskForAPilot : String;
VAR aChoice : Integer;
BEGIN
Show('pilotsmenu');aChoice:=Choice;
IF aChoice>0 THEN BEGIN
PilotName:=Pilots[aChoice];
AskForAPilot:=XWingPATH+'\'+PilotName+'.PLT';
END
ELSE AskForAPilot:='';
Hide('pilotsmenu');
END;
FUNCTION AskForANumber : LongInt;
VAR aLongInt : LongInt;
i,j : Byte;
E : TEvent;
LastHelpLine : String;
BEGIN
LastHelpLine:=HelpLineContent;
HelpLine(EnterNumber);Show('AskNumber');aLongInt:=0;i:=3;
REPEAT
gotoxy(i,1);REPEAT GetKeyEvent(E) UNTIL E.What=evKeyDown;
for j:=0 to 9 do
if (E.KeyCode=Touches09[1,j]) OR (E.KeyCode=Touches09[2,j]) THEN
BEGIN
aLongInt:=aLongInt*10+j;Write(j);Inc(i);
END;
CASE E.KeyCode OF
kbEsc : aLongInt:=-1;
kbDel,kbBack : IF (i>3) THEN BEGIN
aLongInt:=aLongInt DIV 10;
Dec(i);gotoxy(i,1);write(' ');
END;
END;
UNTIL (E.KeyCode=kbEnter) OR (E.KeyCode=kbEsc);
AskForANumber:=aLongInt;
Hide('AskNumber');HelpLine(LastHelpLine);
END;
PROCEDURE MenuLoad;
VAR i : Integer;
begin
ClosePilot;ReadPilots;PilotFilePATH:=AskForAPilot;
IF PilotFilePATH<>'' THEN BEGIN
Assign(PilotFile,PilotFilePATH);Reset(PilotFile);Seek(PilotFile,0);
FOR i:=0 to FileLength DO READ(PilotFile,T[i]);
Close(PilotFile);
aPilotIsLoaded:=True;
for i:=2 to 4 do EnableArticle('main',i);
DisplayPilot;
SetArticleIntitule('main',1,'Load another pilot...');
END;
END;
PROCEDURE MenuAbout;
VAR aStr : String;
LastHelpLine : String;
Key : Char;
aFile : TEXT;
BEGIN
LastHelpLine:=HelpLineContent;
HelpLine(KeyToExit);
Show('About');
TextColor(White);
Assign(aFile,'XWCU.DOC');
IF FSearch('XWCU.DOC',GetCUrrentPath)=''
THEN Erreur('Unable to find About file XWCU.DOC !');
Reset(aFile);
REPEAT ReadLn(aFile,aStr);WriteLn(aStr); UNTIL EOF(aFile);
Close(aFile);Key:=ReadKey;Hide('About');
HelpLine(LastHelpLine);
IF aPilotIsLoaded THEN DisplayPilot;
END;
PROCEDURE StatusMenu;
VAR i : Integer;
aChoice,aChoice2,aChoice3 : Byte;
aNumber : LongInt;
BEGIN
Show('pilotstatus');
REPEAT
aChoice:=Choice;
CASE aChoice OF
1 : BEGIN { Change Pilot Status : Alive,Captured,Killed }
ClearMarks('kindofstatus');
SetArticleMark('kindofstatus',T[Status]+1,'x');
Show('kindofstatus');
aChoice2:=Choice;
IF aChoice2>0 THEN BEGIN
T[Status]:=aChoice2-1;UpDateWindow('Pilot');
END;
Hide('kindofstatus');
END;
2 : BEGIN { Change Pilot Rank : Flight Cadet ... General }
ClearMarks('kindofrank');
SetArticleMark('kindofrank',T[Rank]+1,'x');
Show('kindofrank');aChoice2:=Choice;
IF aChoice2>0 THEN BEGIN
T[Rank]:=aChoice2-1;UpDateWindow('Pilot');
END;
Hide('kindofrank');
END;
3 : BEGIN { Change medals }
for i:=0 to 4 do
IF T[CorellianCross+i]=1 THEN SetArticleMark('medals',i+2,'x')
ELSE SetArticleMark('medals',i+2,' ');
REPEAT
Show('medals');aChoice2:=Choice;
CASE aChoice2 OF
1 : BEGIN
for i:=1 to 7 do SetArticleMark('kalidor',i,' ');
SetArticleMark('kalidor',T[KalidorCrescent]+1,'x');
Show('kalidor');
aChoice3:=Choice;
IF aChoice3>0 THEN BEGIN
T[KalidorCrescent]:=aChoice3-1;
ClearMarks('kalidor');SetArticleMark('kalidor',aChoice,'x');
END;
Hide('kalidor');
END;
2 : IF T[CorellianCross]=1 THEN T[CorellianCross]:=0 ELSE T[CorellianCross]:=1;
3 : IF T[MantooineMedallion]=1 THEN T[MantooineMedallion]:=0 ELSE T[MantooineMedallion]:=1;
4 : IF T[StarOfAlderaan]=1 THEN T[StarOfAlderaan]:=0 ELSE T[StarOfAlderaan]:=1;
5 : If T[YavinShield]=1 THEN T[YavinShield]:=0 ELSE T[YavinShield]:=1;
6 : If T[TalonsOfHoth]=1 THEN T[TalonsOfHoth]:=0 ELSE T[TalonsOfHoth]:=1;
END;
for i:=0 to 4 do
IF T[CorellianCross+i]=1 THEN SetArticleMark('medals',i+2,'x')
ELSE SetArticleMark('medals',i+2,' ');
UNTIL (aChoice2=0);
Hide('medals');
END;
4 : { Change Historic Missions Experience }
BEGIN
aNumber:=AskForANumber;
IF aNumber>=0 THEN BEGIN
WriteInBytes(HistoricXP,aNumber);
UpdateWindow('Pilot');
END;
END;
5 : { Change Tour Of Duty Experience }
BEGIN
aNumber:=AskForANumber;
IF aNumber>=0 THEN BEGIN
WriteInBytes(TODXP,aNumber);
UpdateWindow('Pilot');
END;
END;
END;
UNTIL (aChoice=0);
Hide('pilotstatus');
END;
PROCEDURE HistoricMissionsMenu;
VAR i : Byte;
MenuName : NickName;
WhereCompleted : Integer;
Completed : Boolean;Where:Value;
aChoice1,aChoice2,aChoice3 : Byte;
aNumber : Longint;
BEGIN
Show('crafts');
REPEAT
aChoice1:=Choice;
IF aChoice1>0 THEN BEGIN
Craft:=aChoice1-1;
CASE Craft OF
0 : MenuName:='xwingmissions';
1 : MenuName:='ywingmissions';
2 : MenuName:='awingmissions';
3 : MenuName:='bwingmissions';
END;
ClearMarks(MenuName);
for i:=1 to 6 do
IF T[SuccessfulHistoricMissions+i-1+Craft*16]=1 THEN
SetArticleMark(MenuName,i,'x');
REPEAT
Show(MenuName);aChoice2:=Choice;
IF aChoice2>0 THEN BEGIN
Mission:=aChoice2-1;
SetWindowTitle('Score1',CraftsNames[Craft+1]+' '+GetArticle(MenuName,Mission+1));
Show('Score1');
WhereCompleted:=SuccessfulHistoricMissions+Mission+Craft*16;
Where:=HistoricScores;Where.Offset:=Where.Offset+Mission*4+Craft*64;
Completed:=(T[WhereCompleted]=1);
IF Completed THEN SetArticleIntitule('historicmenu',1,'Set mission to ''Not completed'' ')
ELSE SetArticleIntitule('historicmenu',1,'Set mission to ''Completed'' ');
REPEAT
Show('historicmenu');aChoice3:=Choice;
CASE aChoice3 OF
1 : BEGIN
IF Completed THEN BEGIN
T[WhereCompleted]:=0;Completed:=False;
SetArticleIntitule('historicmenu',1,'Set mission to ''Completed'' ');
SetArticleMark(MenuName,Mission+1,' ');
END
ELSE BEGIN
T[WhereCompleted]:=1;Completed:=True;
SetArticleIntitule('historicmenu',1,'Set mission to ''Not completed'' ');
SetArticleMark(MenuName,Mission+1,'x');
END;
Hide('historicmenu');
END;
2 : BEGIN
aNumber:=AskForANumber;
IF aNumber>=0 THEN WriteInBytes(Where,aNumber);
UpdateWindow('Score1');
END;
END;
UNTIL aChoice3=0;
Hide('historicmenu');Hide('Score1');
END;
UNTIL aChoice2=0;
Hide(MenuName);
END;
UNTIL aChoice1=0;
Hide('crafts');
END;
PROCEDURE ProvingGroundMenu;
VAR Where : Value;
aNumber : LongInt;
aChoice,aChoice2,aChoice3 : Byte;
BEGIN
Show('crafts');
REPEAT
aChoice:=Choice;
IF aChoice>0 THEN BEGIN
Craft:=aChoice-1;
Show('pgroundmenu');
REPEAT
aChoice2:=Choice;
CASE aChoice2 OF
1 : BEGIN
ClearMarks('pilotlevels');
SetArticleMark('pilotlevels',T[TrainingLevels+Craft]+1,'x');
Show('pilotlevels');
aChoice3:=Choice;
IF aChoice3>0 THEN T[TrainingLevels+Craft]:=aChoice3-1;
Hide('pilotlevels');
END;
2 : BEGIN
Where:=TrainingScores;Where.Offset:=Where.Offset+Craft*4;
aNumber:=AskForANumber;
IF aNumber>=0 THEN WriteInBytes(Where,aNumber);
END;
END;
UNTIL aChoice2=0;
Hide('pgroundmenu');
END;
UNTIL aChoice=0;
Hide('crafts');
END;
PROCEDURE TODVictories;
VAR E : TEvent;
H : ARRAY[0..20] of Byte;
DC : KindOfVictories;
i,j : ShortInt;
Where : Value;
aNumber : LongInt;
PROCEDURE WriteIndex(i : Integer; DC : KindOfVictories ; Trace : Boolean);
BEGIN
IF DC=Destroyed THEN gotoxy(28,i+1) ELSE gotoxy(38,i+1);
IF Trace THEN TextColor(Yellow) ELSE TextColor(Blue);
Write('¯');
END;
BEGIN
j:=0;
for i:=0 to 23 do if CraftsNames[i+1]<>'' THEN BEGIN
H[j]:=i;Inc(j);
END;
j:=0;DC:=Destroyed;
REPEAT
Show('Kills');WriteIndex(j,DC,True);
REPEAT
REPEAT GetKeyEvent(E) UNTIL E.What=evKeyDown;
WriteIndex(j,DC,False);
CASE E.KeyCode OF
kbDown : BEGIN { FlŠche basse }
Inc(j);IF j>20 THEN j:=0;
END;
kbUp : BEGIN { FlŠche haute }
Dec(j);IF j<0 THEN j:=20;
END;
kbLeft,kbRight: IF DC=Destroyed THEN DC:=Captured ELSE DC:=Destroyed;
END;
WriteIndex(j,DC,True);
UNTIL (E.KeyCode=kbEnter) OR (E.KeyCode=kbEsc);
IF E.KeyCode=kbEnter THEN BEGIN
IF DC=Destroyed THEN Where:=TODCraftsDestroyed
ELSE Where:=TODCraftsCaptured;
Where.Offset:=Where.Offset+H[j]*2;
aNumber:=AskForANumber;
IF aNumber>=0 THEN WriteInBytes(Where,aNumber);
END
UNTIL E.KeyCode=kbEsc;
Hide('Kills');
end;
PROCEDURE TOD;
VAR i : Integer;
Where : Value;
aChoice1,aChoice2,aChoice3 : Byte;
aNumber : LongInt;
PROCEDURE ShowMarks(aTour : Byte ; aMission : Byte);
VAR i : Integer;
BEGIN
SetArticleMark(TourName[aTour],MenuLength(TourName[aTour]),' ');
for i:=1 to MenuLength(TourName[aTour])-1 DO
IF C[aTour,i-1]=aMission THEN SetArticleMark(TourName[aTour],i,'x')
ELSE SetArticleMark(TourName[aTour],i,' ');
if T[TourStatus+aTour]=3 THEN SetArticleMark(TourName[aTour],MenuLength(TourName[aTour]),'x');
end;
BEGIN
Show('todmenu');
REPEAT
aChoice1:=Choice;
CASE aChoice1 OF
1 : BEGIN { Play Mission... }
Show('tours');
REPEAT
aChoice2:=Choice;
IF aChoice2>0 THEN BEGIN
Tour:=aChoice2-1;
REPEAT
ShowMarks(Tour,T[TourOperation+Tour]);
Show(TourName[Tour]);
aChoice3:=Choice;
IF aChoice3>0 THEN BEGIN
Mission:=aChoice3-1;
T[CurrentTOD]:=Tour;T[$282]:=Mission;
T[$283]:=C[Tour,Mission];T[$287]:=Mission;T[$288]:=$FF;
IF Mission<MenuLength(TourName[Tour])-1 THEN
IF C[Tour,Mission]=C[Tour,Mission+1] THEN T[$288]:=Mission+1;
IF Mission>1 THEN
IF C[Tour,Mission]=C[Tour,Mission-1] THEN BEGIN
T[$287]:=Mission-1;T[$288]:=Mission;
END;
T[TourOperation+Tour]:=C[Tour,Mission];
for i:=TourStatus TO TourStatus+4 DO
IF T[i]<>3 THEN T[i]:=2; { Incomplete }
T[TourStatus+Tour]:=1; { Active }
IF (Mission+1=MenuLength(TourName[Tour])) THEN T[TourStatus+Tour]:=3;
{ Operations available in the Historic Missions }
IF Mission=0 THEN T[$2E8+Tour]:=$FF ELSE T[$2E8+Tour]:=C[Tour,Mission-1];
END;
UNTIL aChoice3=0;
Hide(TourName[Tour]);
END;
UNTIL aChoice2=0;
Hide('tours');
END;
2 : BEGIN { Change scores }
Show('tours');
REPEAT
aChoice2:=Choice;
IF aChoice2>0 THEN BEGIN
Tour:=aChoice2-1;
DisableArticle(TourName[Tour],MenuLength(TourName[Tour]));
REPEAT
Show(TourName[Tour]);
aChoice3:=Choice;
IF aChoice3>0 THEN BEGIN
Mission:=aChoice3-1;
Where:=TODScores;Where.Offset:=Where.Offset+Tour*100+Mission*4;
SetWindowTitle('Score2',TourName[Tour]+' '+GetArticle(TourName[Tour],Mission+1));
Show('Score2');aNumber:=AskForANumber;
IF aNumber>=0 THEN WriteInBytes(Where,aNumber);
Hide('Score2');
END;
UNTIL aChoice3=0;
EnableArticle(TourName[Tour],MenuLength(TourName[Tour]));
Hide(TourName[Tour]);
END;
UNTIL aChoice2=0;
Hide('tours');
END;
3 : TODVictories;
4 : BEGIN { TOD Statistics }
Show('statistics');
REPEAT
aChoice2:=Choice;
IF aChoice2>0 THEN aNumber:=AskForANumber;
IF aNumber>=0 THEN
CASE aChoice2 OF
1 : WriteInBytes(TODSurfaceVictories,aNumber);
2 : WriteInBytes(TODLaserFired,aNumber);
3 : WriteInBytes(TODLaserCraftHits,aNumber);
4 : WriteInBytes(TODLaserGroundHits,aNumber);
5 : WriteInBytes(TODHomingProjFired,aNumber);
6 : WriteInBytes(TODHPCraftHits,aNumber);
7 : WriteInBytes(TODHPGroundHits,aNumber);
8 : WriteInBytes(TODCraftsLost,aNumber);
END;
UNTIL aChoice2=0;
Hide('statistics');
END;
END;
UNTIL aChoice1=0;
Hide('todmenu');
END;
PROCEDURE EditMenu;
VAR aChoice : Byte;
BEGIN
Show('edit');
REPEAT
aChoice:=Choice;
CASE aChoice OF
1 : StatusMenu;
2 : ProvingGroundMenu;
3 : HistoricMissionsMenu;
4 : TOD;
END;
Modified:=True;
UNTIL aChoice=0; { ESC }
Hide('edit');
END;
PROCEDURE Quit;
BEGIN
ClosePilot;
TextBackGround(Black);TextColor(White);SetWindow(MaxWindow);ClrScr;
WriteLn('Leaving X-Wing Cheat Utility... Back to DOS !');
END;
PROCEDURE Utilities;
VAR aChoice,i,Alive : Byte;
aFile : FILE of Byte;
BEGIN
Show('utilities');
aChoice:=Choice;Alive:=0;ReadPilots;
CASE aChoice OF
1 : for i:=1 to NbrOfPilots do begin
Assign(aFile,XwingPATH+'/'+Pilots[i]+'.PLT');Reset(aFile);
Seek(aFile,Status);Write(aFile,Alive);
Close(aFile);
END;
END;
Hide('utilities');
END;
PROCEDURE MainMenu;
VAR aChoice : Byte;
BEGIN
HelpLine(HelpLine1);HeadLine(MainHeadLine);
REPEAT
Show('main');aChoice:=Choice;
CASE aChoice OF
1 : MenuLoad;
2 : EditMenu;
3 : BEGIN
HelpLine(KeyToContinue);Show('PilotLog');Hide('PilotLog');
HelpLine(HelpLine1);
END;
4 : WritePilot;
5 : Utilities;
6 : MenuAbout;
END;
UNTIL (aChoice=7) OR (aChoice=0); { User wants to quit }
Quit;
END;
BEGIN
Init;InstallFont('t.fnt');
LoadData;
MainMenu;
END. |
unit frmSerialNumberDialogView;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uDialogParent, siComp, siLangRT, StdCtrls, ExtCtrls;
type
TfrmSerialDgView = class(TDialogParent)
lblSerialType: TLabel;
lblValue: TLabel;
edtSerialNumber: TEdit;
procedure AplicarClick(Sender: TObject);
procedure CancelarClick(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure edtSerialNumberKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
private
{ Private declarations }
fIdInvoice: Integer;
FSerialNumber: String;
FInternal: Boolean;
FIdModel: Integer;
FIdStore: Integer;
FIdItem: Integer;
FMaxQty: Integer;
FBalance: Double;
FcountQty: Integer;
FMsg: String;
procedure setIdModel(const Value: Integer);
procedure setIdMov(const Value: Integer);
procedure setIdStore(const Value: Integer);
procedure refreshLabel();
procedure writeSerialNumber(serial_number: String);
public
{ Public declarations }
property IdModel: Integer write setIdModel;
property IdStore: Integer write setIdStore;
property IdMov: Integer write setIdMov;
function Start(msg_gift: String; ini_qty, end_qty, idmodel, iditem: Integer;
balance: Double; arg_invoice: Integer = -1): Boolean;
end;
implementation
uses uCreditCardFunction, SerialNumberCls, uDM, ufrmPCCSwipeCard;
{$R *.dfm}
{ TfrmSerialDgView }
function TfrmSerialDgView.Start(msg_gift: String; ini_qty, end_qty, idmodel, iditem: Integer;
balance: Double; arg_invoice: Integer): Boolean;
begin
FMaxQty := end_qty;
FBalance := balance;
FcountQty := 0;
FMsg := msg_gift;
FIdModel := idmodel;
FIdItem := iditem;
FIdStore := dm.fStore.ID;
fIdInvoice := arg_invoice;
refreshLabel();
result := (ShowModal = mrOk);
end;
procedure TfrmSerialDgView.AplicarClick(Sender: TObject);
begin
FSerialNumber := edtSerialNumber.Text;
WriteSerialNumber(FSerialNumber);
refreshLabel();
end;
procedure TfrmSerialDgView.setIdModel(const Value: Integer);
begin
FIdModel := Value;
end;
procedure TfrmSerialDgView.setIdMov(const Value: Integer);
begin
FIdItem := Value;
end;
procedure TfrmSerialDgView.setIdStore(const Value: Integer);
begin
FIdStore := Value;
end;
procedure TfrmSerialDgView.refreshLabel();
var
msg: String;
begin
inc(FCountQty);
msg := format(FMsg + '%d of %d', [FcountQty, FMaxQty]);
lblSerialType.Caption := msg;
lblValue.Caption := '($' + formatFloat('#,##0.00', FBalance) + ')';
edtSerialNumber.Clear;
if ( FCountQty > FMaxQty ) then
close();
end;
procedure TfrmSerialDgView.WriteSerialNumber(serial_number: String);
var
objSerialNumber: TSerialNumberFromPreSale;
serialNumber: String;
begin
try
try
// Antonio 06/01/2016 - to protect this transaction and avoid orphan records
dm.ADODBConnect.BeginTrans;
objSerialNumber := TSerialNumberFromPreSale.Create(FIdModel, FIdStore, FIdItem, trunc(FMaxQty));
objSerialNumber.Connection := dm.ADODBConnect;
objSerialNumber.IdInvoice := fIdInvoice;
if ( not objSerialNumber.isDuplicateSerial(serial_number) ) then begin
if ( objSerialNumber.addAccountNumber(serial_number) ) then
objSerialNumber.Add(FIdItem, serial_number, '', '0');
end;
dm.ADODBConnect.CommitTrans;
except
on e: Exception do begin
dm.ADODBConnect.RollbackTrans;
raise Exception.Create('Error found when tried add serial number: ' + e.Message);
end;
end;
finally
freeAndNil(objSerialNumber);
end;
end;
procedure TfrmSerialDgView.CancelarClick(Sender: TObject);
begin
inherited;
if ( application.MessageBox('Cancel ALL serials numbers ?', 'Cancel', mb_YESNO + MB_ICONQUESTION) = idYes ) then begin
dm.fMRMercury.QtyToRemove := FMaxQty;
fCountQty := FMaxQty + 1;
close();
end
else begin
dm.fMRMercury.QtyToRemove := dm.fMRMercury.QtyToRemove + 1;
refreshLabel();
end;
end;
procedure TfrmSerialDgView.FormCloseQuery(Sender: TObject;
var CanClose: Boolean);
begin
inherited;
canClose := ( FcountQty > FMaxQty );
end;
procedure TfrmSerialDgView.edtSerialNumberKeyDown(Sender: TObject;
var Key: Word; Shift: TShiftState);
begin
inherited;
if ( key = VK_RETURN ) then begin
AplicarClick(sender);
end;
end;
end.
|
unit uFaceRecognizerService;
interface
uses
Generics.Collections,
System.SysUtils,
System.Classes,
System.Math,
Vcl.Graphics,
OpenCV.Utils,
Dmitry.Utils.Files,
uConstants,
uMemory,
uBitmapUtils,
uConfiguration,
uFaceDetection,
uFaceRecognizer,
uFaceAnalyzer,
uDBEntities;
type
IFoundPerson = interface
function ExtractBitmap: TBitmap;
function GetPersonId: Integer;
function GetStars: Byte;
function GetPercents: Byte;
end;
IRelatedPersonsCollection = interface
function Count: Integer;
function GetPerson(Index: Integer): IFoundPerson;
function GetPersonById(PersonId: Integer): IFoundPerson;
function HasMatches: Boolean;
end;
TFaceDetectonOption = (fdoImage);
TFaceDetectonOptions = set of TFaceDetectonOption;
type
TFoundPerson = class(TInterfacedObject, IFoundPerson)
private
FImage: TBitmap;
FPersonId: Integer;
FPercents: Byte;
FStars: Integer;
public
constructor Create(Stars: Integer; FDR: TFaceRecognitionResult);
destructor Destroy; override;
function ExtractBitmap: TBitmap;
function GetPersonId: Integer;
function GetPercents: Byte;
function GetStars: Byte;
end;
TRelatedPersonsCollection = class(TInterfacedObject, IRelatedPersonsCollection)
private
FPersons: TList<IFoundPerson>;
public
constructor Create(FDRs: TFaceRecognitionResults);
destructor Destroy; override;
function Count: Integer;
function GetPerson(Index: Integer): IFoundPerson;
function GetPersonById(PersonId: Integer): IFoundPerson;
function HasMatches: Boolean;
end;
type
TFaceRecognizerService = class
private
FRecognizer: IFaceRecognizer;
FDetector: TFaceDetectionManager;
function CacheDirectory: string;
public
constructor Create;
destructor Destroy; override;
function HasFaceArea(AreaId: Integer): Boolean;
function UserSelectedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
function UserChangedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
function UserRemovedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
function FindRelatedPersons(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): IRelatedPersonsCollection;
//For The Future, currently detection rate is too low to use automatic detection 2014/01/05
function DetectPersonId(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Integer;
function IsActive: Boolean;
end;
function UIFaceRecognizerService: TFaceRecognizerService;
implementation
const
MaxFaces = 80;
FacesPerPerson = 10;
MinFaceScore = 0;//60;
FaceWidth = 64;
FaceHeight = 64;
MaxPersonsToSearch = 5;
var
AUIFaceRecognizerService: TFaceRecognizerService = nil;
function UIFaceRecognizerService: TFaceRecognizerService;
begin
if AUIFaceRecognizerService = nil then
AUIFaceRecognizerService := TFaceRecognizerService.Create;
Result := AUIFaceRecognizerService;
end;
{ TFaceRecognizerService }
function TFaceRecognizerService.CacheDirectory: string;
begin
Result := GetAppDataDirectory + FaceTrainCacheDirectory;
end;
constructor TFaceRecognizerService.Create;
begin
if not LoadOpenCV then
Exit;
FRecognizer := TFaceEigenRecognizer.Create(FaceWidth, FaceHeight, FacesPerPerson, MaxFaces);
FDetector := TFaceDetectionManager.Create;
FRecognizer.LoadState(CacheDirectory);
end;
destructor TFaceRecognizerService.Destroy;
begin
if not LoadOpenCV then
Exit;
DeleteDirectoryWithFiles(CacheDirectory);
FRecognizer.SaveState(CacheDirectory);
FRecognizer := nil;
F(FDetector);
end;
function TFaceRecognizerService.DetectPersonId(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Integer;
begin
raise ENotSupportedException.Create('Detection currently is not supported!');
end;
function TFaceRecognizerService.FindRelatedPersons(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): IRelatedPersonsCollection;
var
FDR: TFaceRecognitionResults;
DR: TFaceScoreResults;
FaceSample: TBitmap;
begin
if not LoadOpenCV then
Exit;
DR := ProcessFaceAreaOnImage(MI, Image, Area, FDetector, MinFaceScore);
try
if DR = nil then
Exit;
FaceSample := TBitmap.Create;
try
DR.GenerateSample(FaceSample, FaceWidth, FaceHeight);
FDR := FRecognizer.RecognizeFace(FaceSample, MaxPersonsToSearch);
try
Result := TRelatedPersonsCollection.Create(FDR);
finally
F(FDR);
end;
finally
F(FaceSample);
end;
finally
F(DR);
end;
end;
function TFaceRecognizerService.HasFaceArea(AreaId: Integer): Boolean;
begin
if not LoadOpenCV then
Exit(False);
Result := FRecognizer.HasFace(AreaId);
end;
function TFaceRecognizerService.IsActive: Boolean;
begin
Result := HasOpenCV;
end;
function TFaceRecognizerService.UserChangedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
begin
if not LoadOpenCV then
Exit(False);
Result := FRecognizer.MoveFaceToAnotherPerson(Area.ID, Area.PersonID);
end;
function TFaceRecognizerService.UserRemovedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
begin
if not LoadOpenCV then
Exit(False);
Result := FRecognizer.RemoveFaceById(Area.ID);
end;
function TFaceRecognizerService.UserSelectedPerson(MI: TMediaItem; Image: TBitmap; Area: TPersonArea): Boolean;
var
DR: TFaceScoreResults;
FaceSample, FaceImage: TBitmap;
begin
Result := False;
if not LoadOpenCV then
Exit;
DR := ProcessFaceAreaOnImage(MI, Image, Area, FDetector, MinFaceScore);
try
if DR = nil then
Exit;
FaceSample := TBitmap.Create;
try
DR.GenerateSample(FaceSample, FaceWidth, FaceHeight);
FaceImage := nil;
if DR.FaceImage <> nil then
begin
FaceImage := TBitmap.Create;
FaceImage.Assign(DR.FaceImage);
end;
Result := FRecognizer.TrainFace(FaceSample, FaceImage, Area.PersonID, Area.ID, DR.TotalScore);
finally
F(FaceSample);
end;
finally
F(DR);
end;
end;
{ TRelatedPersonsCollection }
function TRelatedPersonsCollection.Count: Integer;
begin
Result := FPersons.Count;
end;
constructor TRelatedPersonsCollection.Create(FDRs: TFaceRecognitionResults);
var
I: Integer;
begin
FPersons := TList<IFoundPerson>.Create;
for I := 0 to FDRs.Count - 1 do
FPersons.Add(TFoundPerson.Create(FDRs.Count - I, FDRs[I]));
end;
destructor TRelatedPersonsCollection.Destroy;
begin
F(FPersons);
inherited;
end;
function TRelatedPersonsCollection.GetPerson(Index: Integer): IFoundPerson;
begin
Result := FPersons[Index];
end;
function TRelatedPersonsCollection.GetPersonById(PersonId: Integer): IFoundPerson;
var
I: Integer;
begin
Result := nil;
for I := 0 to FPersons.Count - 1 do
if FPersons[I].GetPersonId = PersonId then
Exit(FPersons[I]);
end;
function TRelatedPersonsCollection.HasMatches: Boolean;
var
I: Integer;
begin
Result := False;
for I := 0 to FPersons.Count - 1 do
if FPersons[I].GetPercents > 0 then
Exit(True);
end;
{ TFoundPerson }
constructor TFoundPerson.Create(Stars: Integer; FDR: TFaceRecognitionResult);
begin
FImage := FDR.ExtractBitmap;
FPersonId := FDR.PersonId;
FPercents := Ceil(FDR.Percents);
FStars := Stars;
end;
destructor TFoundPerson.Destroy;
begin
F(FImage);
inherited;
end;
function TFoundPerson.ExtractBitmap: TBitmap;
begin
Result := FImage;
FImage := nil;
end;
function TFoundPerson.GetPercents: Byte;
begin
Result := FPercents;
end;
function TFoundPerson.GetPersonId: Integer;
begin
Result := FPersonId;
end;
function TFoundPerson.GetStars: Byte;
begin
Result := FStars;
end;
initialization
finalization
F(AUIFaceRecognizerService);
end.
|
(*
Category: SWAG Title: ANYTHING NOT OTHERWISE CLASSIFIED
Original name: 0141.PAS
Description: Finding Pentium FDiv Error
Author: WILLIAM G. S. BROWN
Date: 05-26-95 23:07
*)
{
From: brownwm@aplcenmp.apl.jhu.edu (William G. S. Brown)
Here is a short Pentium test program that will uncover the FDIV
error. Note: Sometimes just setting X&Y then then printing
X-(X/Y)*Y will not show the error because the optimization is
smart enough to form the answer at compile time.
}
Program Pentium;
{ test a Pentium for FDIV error }
{ computes X-(X/Y)*Y which should be 0.000000}
{ Good Pentium should return 0.000000000E+0000}
{ Bad Pentium will return 2.560000000E+0002}
var
X,Y: double;
{ the procedure is to make sure optimization won't hide error }
procedure Test( A,B,C,D : double);
begin { Test }
writeln(A-(B/C)*D);
end; { Test }
begin { Pentium }
X := 4195835;
Y := 3145727;
Test(X, X, Y, Y); { same as X-(X/Y)*Y e.g. 0.0000}
end. { Pentium }
|
unit Objekt.OptionList;
interface
uses
SysUtils, Classes, Contnrs, Objekt.BaseList, Objekt.Option;
type
TOptionList = class(TBaseList)
private
function getOption(Index: Integer): TOption;
public
constructor Create; override;
destructor Destroy; override;
function Add: TOption;
property Item[Index: Integer]: TOption read getOption;
procedure SaveToFile(aFullFilename: string);
procedure LoadFromFile(aFullFilename: string);
procedure LoadFromString(aValue: string);
procedure Delete(aId: Integer);
end;
implementation
{ TOptionList }
uses
Objekt.Allgemein;
constructor TOptionList.Create;
begin
inherited;
end;
destructor TOptionList.Destroy;
begin
inherited;
end;
function TOptionList.Add: TOption;
begin
Result := TOption.Create;
inc(fId);
Result.Id := fId;
fList.Add(Result);
end;
function TOptionList.getOption(Index: Integer): TOption;
begin
Result := nil;
if Index > fList.Count -1 then
exit;
Result := TOption(fList[Index]);
end;
procedure TOptionList.LoadFromFile(aFullFilename: string);
var
Liste : TStringList;
Plain: string;
begin
if not FileExists(aFullFilename) then
exit;
Liste := TStringList.Create;
try
Liste.LoadFromFile(aFullFilename);
Plain := AllgemeinObj.Entschluesseln(Liste.Text);
LoadFromString(Plain);
finally
FreeAndNil(Liste);
end;
end;
{
procedure TOptionList.LoadFromFile(aFullFilename: string);
var
Liste : TStringList;
i1: Integer;
Option: TOption;
begin
fList.Clear;
if not FileExists(aFullFilename) then
exit;
Liste := TStringList.Create;
try
Liste.LoadFromFile(aFullFilename);
for i1 := 0 to Liste.Count -1 do
begin
Option := Add;
Option.setCSVLine(Liste.Strings[i1]);
end;
finally
FreeAndNil(Liste);
end;
end;
}
procedure TOptionList.LoadFromString(aValue: string);
var
Liste : TStringList;
i1: Integer;
Option: TOption;
begin
fList.Clear;
Liste := TStringList.Create;
try
Liste.Text := aValue;
for i1 := 0 to Liste.Count -1 do
begin
Option := Add;
Option.setCSVLine(Liste.Strings[i1]);
end;
finally
FreeAndNil(Liste);
end;
end;
procedure TOptionList.SaveToFile(aFullFilename: string);
var
i1: Integer;
Liste: TStringList;
s: string;
begin
if FileExists(aFullFilename) then
DeleteFile(aFullFilename);
Liste := TStringList.Create;
try
for i1 := 0 to fList.Count -1 do
begin
s := TOption(fList.Items[i1]).getCSVLine;
Liste.Add(s);
end;
Liste.Text := AllgemeinObj.Verschluesseln(Liste.Text);
Liste.SaveToFile(aFullFilename);
finally
FreeAndNil(Liste);
end;
end;
procedure TOptionList.Delete(aId: Integer);
var
i1: Integer;
begin
for i1 := 0 to fList.Count -1 do
begin
if TOption(fList.Items[i1]).Id = aId then
begin
fList.Delete(i1);
exit;
end;
end;
end;
end.
|
(*
NUME AUTOR: Mitrea Cristina
SUBIECT: Teoria grafelor
TEMA NR.: 3
PROBLEMA:
Sa se conceapa un algorim care determina si afiseaza marjele de timp pentru
fiecare activitate din desfasurarea unui obiectiv.
Acest obiectiv se poate reprezenta sub forma grafului potentiale ....
Se considera ca G=(X,U) (X={1,2,3,...,n}) unde G este un graf simplu cu
valori pozitive ale arcelor.
NOTATII:
-INFINIT-valoarea drumului de la vf. i la vf. j, pntru care nu exista drum
de la i la j
l(i,j)=l(u) : valoarea arcului (i,j)
| -INFINIT daca i=j |
v(i,j)=| l(i,j) daca (i,j) apartine lui U | : matricea valorilor arcelor
| -INFINIT daca (i,j) nu apartine lui U |
H(j)=| -INFINIT, daca j=p | : valoarea maxima
| v(1,j), i=1,n) daca j<>p | a drumurilor de la 1 la j
: daca nu exista drum,
val max=INFINIT
S(i)=|0, daca pentru vf. i s-a det. val. max a drumului de la p la i|
|i, altfel |
S-multimea vf. pt care s-a det. val. max a drumului de la p la i
PROIECTARE:
Algoritmul lui Moore-Dijkstra care determina valorile minime drumurilor
de la varful 1 la vf. i, unde i apartine multimii {1,...,n}-{p}:
(a)initialzari
H(1):=0;
H(i):=|l(p,i), i succesor al lui 1|
|INFINIT,altfel |
s:={2,3,..,n}
(b)testul de stop
| * fie j din S a.i. H(j)=min{H(i)/i din S}
s:=S-{j}
daca S={} atunci stop
sfdaca
(c)iteratia de baza
pentru | * i din intersectie de Succesori(j) si S executa
H(i):=min{H(I),H(j)+v(j,i)
sfpentru
goto (b)
Algoritmul lui Moore-Dijkstra adaptat pentru determinarea maximului
lungimilor drumurilor de la 1 la i unde i apartine multimii {1,...,n}-{p}:
in algoritmul anterior se inlocuieste min cu max si "<" cu ">"
H(i):=|v(1,i),i<>1 |
|INFINIT,i=1 |
s:={2,3,..,n}
repeta
| * fie j din S a.i. H(j)=max{H(i)/i din S}
s:=S-{j}
pentru | * i din intersectie de Succesori(j) si S executa
H(i):=max{H(I),H(j)+v(j,i)
sfpentru
pana cand S={}
Pentru determinarea marjelor utilizam formula de calcul a acestora:
m(i):=T(I)-t(i), pt. oricare i din X
unde
t(i)-momentul cel mai devreme la care poate ...
T(i)-...
Vectorul t(i) il det cu M-j adaptat(vectorul H)
Vectorul T(i) il det. reursiv cu formula :
| T(i):=T(succ(i))-v(i,succ(i))
| T[n]=t(i) , i:=n-1,2
activitatile 1,n sunt activitati critice, deci
m(1)=0
m(n)=0
EXEMPLU:
Date
4
1 2 4
1 3 7
2 4 5
3 4 2
0 0 0
Rezultate
Marja de timp a lui 4 este:0
Marja de timp a lui 3 este:0
Marja de timp a lui 2 este:1
Marja de timp a lui 1 este:0
*)
const MAX=20;
INFINIT=10000;
type tab=array[0..MAX] of integer;
mat=array[0..MAX] of tab;
function arc(i,j:integer; v:mat):boolean;
begin
arc:= (v[i,j]<>-INFINIT)
end;
procedure InitCit(w:string;
var n:integer; var v:mat;
var H,S:tab);
var i,j,k:integer;
f:text;
begin
assign(f,w);
reset(f);
for i:=1 to MAX do
for j:=1 to MAX do v[i,j]:=-INFINIT;
readln(f,n);
for i:=0 to n+1 do
begin
v[i,0]:=-INFINIT;
v[n+1,i]:=-INFINIT;
v[0,i]:=0;
v[i,n+1]:=0;
end;
v[0,0]:=-INFINIT;
v[0,n+1]:=-INFINIT;
v[n+1,n+1]:=-INFINIT;
readln(f,i,j,k);
while i<>0 do begin
v[i,j]:=k;
if k<>0 then
begin
v[0,j]:=-INFINIT;
v[i,n+1]:=-INFINIT;
end;
readln(f,i,j,k)
end;
H[0]:=INFINIT;
S[0]:=INFINIT;
for i:=1 to n+1 do
begin
H[i]:=v[0,i];
S[i]:=i;
end;
close(f)
end;
function evida(n:integer; S:tab):boolean;
var vb:boolean;
i:integer;
begin
vb:=true;
for i:=1 to n do
if (S[i]<>0) then vb:=false;
evida:=vb;
end;
procedure Dijkstra(n:integer; v:mat; var H,S:tab);
var i,j,maxim:integer;
begin
repeat
maxim:=-INFINIT;
j:=-1;
for i:=1 to n do
if ((S[i]<>0)and(H[S[i]]>=maxim)) then
begin
maxim:=H[S[i]];
j:=S[i];
end;
S[j]:=0;
for i:=1 to n do
if (arc(j,i,v)and(S[i]=i))
then if (H[j]+v[j,i] > H[i])
then H[i]:=H[j]+v[j,i];
until evida(n,S);
for i:=1 to n do
if (arc(i,n,v)and(h[n]<h[i]+v[i,n])) then h[n]:=h[i]+v[i,n];
end;
function succesor(v:mat; n:integer; vf:integer):integer;
var i,m:integer;
begin
succesor:=-1;
m:=infinit;
for i:=1 to n do
if (v[vf,i]<>-infinit)and(v[vf,i]<m) then
begin
m:=v[vf,i];
succesor:=i;
end;
end;
procedure Tip(n:integer; v:mat; H:tab);
var i,s,m:integer;
T:tab;
begin
T[n]:=H[n];
writeln('Marja de timp a lui ',n,' este: ',0);
for i:=n-1 downto 2 do
begin
s:=succesor(v,n,i);
T[i]:=T[s]-v[i,s];
m:=T[s]-v[i,s]-H[i];
writeln('Marja de timp a lui ',i,' este: ',m);
end;
writeln('Marja de timp a lui ',1,' este: ',0);
end;
var n,i:integer;
v:mat;
H,S:tab;
begin
InitCit('tema2.dat',n,v,H,S);
Dijkstra(n,v,H,S);
Tip(n,v,H);
readln;
end.
|
unit SearchSort;
{$WEAKPACKAGEUNIT ON}
interface
uses SysUtils, UniStrUtils;
type
//Возвращает > 0, если объект больше объекта на позиции pos. Ноль, если равны.
TCompareProcP = function(data: pointer; obj: pointer; pos: integer): integer;
//Обратная совместимость: Возвращает > 0, если позиция I больше объекта
TItemCmpProc = function(Data: pointer; I: integer; Item: pointer): integer;
//Возвращает > 0, если элемент 1 больше элемента 2. Ноль, если они равны.
TCompareProcI = function(data: pointer; i1, i2: integer): integer;
//Перемещает элемент I на место NewI, сдвигая остальное вниз. I всегда >= NewI.
TMoveProcI = procedure(data: pointer; I, NewI: integer);
//Меняет местами элементы i1 и i2
TExchangeProcI = procedure(data: pointer; i1, i2: integer);
function LinSearch(Data: pointer; Len: integer; Item: pointer; Cmp: TItemCmpProc;
out k: integer): Boolean;
function BinSearch(Data: pointer; Len: integer; Item: pointer; Cmp: TItemCmpProc;
out k: integer): Boolean;
//Пузырьковая сортировка. Получает сравнивалку и перемещаловку.
procedure BubbleSort(data: pointer; len: integer; cmp: TCompareProcI; mov: TMoveProcI);
//Быстрая сортировка. Получает сравнивалку и перестанавливалку.
//Взято с http://www.vb-helper.com/dart1.htm, чуточку подправлено.
//L, R - граничные элементы, включительно.
procedure QuickSort(data: pointer; L, R: Integer; cmp: TCompareProcI; xch: TExchangeProcI);
(*
Готовые сравнивалки.
*)
type
TIntArray = array of integer;
//Expects Data to be TIntArray
function Cmp_IntArray_Asc(Data: pointer; I, J: integer): integer;
function Cmp_IntArray_Desc(Data: pointer; I, J: integer): integer;
procedure Mov_IntArray(Data: pointer; I, NewI: integer);
procedure Xch_IntArray(Data: pointer; i1, i2: integer);
//Expects Data to be TStringArray
function Cmp_StringArray_StrAsc(Data: pointer; I, J: integer): integer;
function Cmp_StringArray_StrDesc(Data: pointer; I, J: integer): integer;
function Cmp_StringArray_TextAsc(Data: pointer; I, J: integer): integer;
function Cmp_StringArray_TextDesc(Data: pointer; I, J: integer): integer;
procedure Mov_AnyStringArray(Data: pointer; I, NewI: integer);
//Expects Data to be TUniStringArray
function Cmp_UniStringArray_StrAsc(Data: pointer; I, J: integer): integer;
function Cmp_UniStringArray_StrDesc(Data: pointer; I, J: integer): integer;
function Cmp_UniStringArray_TextAsc(Data: pointer; I, J: integer): integer;
function Cmp_UniStringArray_TextDesc(Data: pointer; I, J: integer): integer;
implementation
function LinFindPos(data: pointer; obj: pointer; cmp: TCompareProcP; len: integer;
out k: integer): Boolean;
var i, diff: integer;
begin
Result := false;
for i := 0 to Len - 1 do begin
diff := Cmp(Data, obj, i);
if diff<=0 then begin
k := i;
Result := diff=0;
Exit;
end;
end;
end;
//Возвращает true, если нашли точное совпадение. В таком случае указывает на первый совпадающий элемент.
//Иначе указывает на первый элемент больше нужного.
function BinFindPos(data: pointer; obj: pointer; cmp: TCompareProcP; len: integer; out k: integer): boolean;
var k_left, k_right: integer;
diff_val: integer;
begin
Result := false;
if len<=0 then begin
k := 0;
exit; //Иначе потом будут странные исключительные случаи
end;
//Ищем бинарным поиском
k_left := 0;
k_right := len-1;
k := 0;
while k_right-k_left > 0 do begin
k := k_left + (k_right - k_left) div 2;
diff_val := cmp(data, obj, k);
if diff_val < 0 then begin
k_right := k - 1;
end else
if diff_val > 0 then begin
k_left := k + 1;
end else
begin
//Находим первый совпадающий
repeat
Dec(k);
until (k < k_left) or (cmp(data, obj, k) <> 0);
Inc(k);
Result := true;
exit;
end;
end;
//Здесь оказываемся только если k_right=k_left (оба края включительно).
//Проверяем последнюю клетку - указывать на неё, или на следующую?
diff_val := cmp(data, obj, k_left);
if diff_val < 0 then begin
k := k_left;
Result := false;
end else
if diff_val = 0 then begin
k := k_left;
Result := true;
end else begin
k := k_left+1;
Result := false;
end;
end;
(*
Обратная совместимость: чуточку иные функции бинарного поиска.
*)
type
TSearchData = record
Data: Pointer;
Cmp: TCompareProcP;
end;
PSearchData = ^TSearchData;
//Внутренний преобразователь пользовательской функции
function ItemCmpProc(Data: pointer; I: integer; Item: pointer): integer;
begin
Result := - PSearchData(data).Cmp(PSearchData(data)^.Data, Item, I);
end;
function LinSearch(Data: pointer; Len: integer; Item: pointer; Cmp: TItemCmpProc;
out k: integer): Boolean;
var SearchData: TSearchData;
begin
SearchData.Data := Data;
SearchData.Cmp := @Cmp;
Result := LinFindPos(@SearchData, Item, @ItemCmpProc, Len, k);
end;
function BinSearch(Data: pointer; Len: integer; Item: pointer; Cmp: TItemCmpProc;
out k: integer): Boolean;
var SearchData: TSearchData;
begin
SearchData.Data := Data;
SearchData.Cmp := @Cmp;
Result := BinFindPos(@SearchData, Item, @ItemCmpProc, Len, k);
end;
//Пузырьковая сортировка. Получает сравнивалку и перемещаловку.
procedure BubbleSort(Data: pointer; Len: integer; Cmp: TCompareProcI; Mov: TMoveProcI);
var i, j: integer;
begin
for i := 1 to Len - 1 do begin
j := i-1;
while (j >= 0) and (Cmp(Data, i, j) < 0) do
Dec(j);
Inc(j);
if j <> i then
Mov(data, i, j);
end;
end;
procedure QuickSort(Data: pointer; L, R: Integer; Cmp: TCompareProcI; Xch: TExchangeProcI);
var I, J, P: Integer;
begin
if L>R then exit;
repeat
I := L;
J := R;
P := (L + R) shr 1;
repeat
while Cmp(Data, I, P) < 0 do
Inc(I);
while Cmp(Data, J, P) > 0 do
Dec(J);
if I <= J then
begin
//ExchangeItems
if I <> J then
Xch(Data, I, J);
if P = I then
P := J
else if P = J then
P := I;
Inc(I);
Dec(J);
end;
until I > J;
if L < J then
QuickSort(Data, L, J, Cmp, Xch);
L := I;
until I >= R;
end;
function Cmp_IntArray_Asc(Data: pointer; I, J: integer): integer;
begin
Result := TIntArray(Data)[i] - TIntArray(Data)[j];
end;
function Cmp_IntArray_Desc(Data: pointer; I, J: integer): integer;
begin
Result := TIntArray(Data)[j] - TIntArray(Data)[i];
end;
procedure Mov_IntArray(Data: pointer; I, NewI: integer);
var tmp: integer;
begin
tmp := TIntArray(Data)[I];
while I > NewI do begin
TIntArray(Data)[I] := TIntArray(Data)[I-1];
Dec(I);
end;
TIntArray(Data)[NewI] := tmp;
end;
procedure Xch_IntArray(Data: pointer; i1, i2: integer);
var tmp: integer;
begin
tmp := TIntArray(Data)[i1];
TIntArray(Data)[i1] := TIntArray(Data)[i2];
TIntArray(Data)[i2] := tmp;
end;
function Cmp_StringArray_StrAsc(Data: pointer; I, J: integer): integer;
begin
Result := CompareStr(TStringArray(Data)[i], TStringArray(Data)[j]);
end;
function Cmp_StringArray_StrDesc(Data: pointer; I, J: integer): integer;
begin
Result := CompareStr(TStringArray(Data)[j], TStringArray(Data)[i]);
end;
function Cmp_StringArray_TextAsc(Data: pointer; I, J: integer): integer;
begin
Result := CompareText(TStringArray(Data)[i], TStringArray(Data)[j]);
end;
function Cmp_StringArray_TextDesc(Data: pointer; I, J: integer): integer;
begin
Result := CompareText(TStringArray(Data)[j], TStringArray(Data)[i]);
end;
procedure Mov_AnyStringArray(Data: pointer; I, NewI: integer);
var tmp: integer;
j: integer;
begin
//Move as for IntArray: save on string reference counting
tmp := TIntArray(Data)[I];
for j := I downto NewI + 1 do
TIntArray(Data)[j] := TIntArray(Data)[j-1];
TIntArray(Data)[NewI] := tmp;
end;
function Cmp_UniStringArray_StrAsc(Data: pointer; I, J: integer): integer;
begin
{$IF CompilerVersion >= 21}
Result := CompareStr(TStringArray(Data)[i], TStringArray(Data)[j]);
{$ELSE}
Result := WideCompareStr(TWideStringArray(Data)[i], TStringArray(Data)[j]);
{$IFEND}
end;
function Cmp_UniStringArray_StrDesc(Data: pointer; I, J: integer): integer;
begin
{$IF CompilerVersion >= 21}
Result := CompareStr(TStringArray(Data)[j], TStringArray(Data)[i]);
{$ELSE}
Result := WideCompareStr(TWideStringArray(Data)[j], TStringArray(Data)[i]);
{$IFEND}
end;
function Cmp_UniStringArray_TextAsc(Data: pointer; I, J: integer): integer;
begin
{$IF CompilerVersion >= 21}
Result := CompareText(TStringArray(Data)[i], TStringArray(Data)[j]);
{$ELSE}
Result := WideCompareText(TWideStringArray(Data)[i], TStringArray(Data)[j]);
{$IFEND}
end;
function Cmp_UniStringArray_TextDesc(Data: pointer; I, J: integer): integer;
begin
{$IF CompilerVersion >= 21}
Result := CompareText(TStringArray(Data)[j], TStringArray(Data)[i]);
{$ELSE}
Result := WideCompareText(TWideStringArray(Data)[j], TStringArray(Data)[i]);
{$IFEND}
end;
end.
|
unit uLandMark;
interface
uses
JsonDataObjects, Ils.Json.Names, Ils.Json.Utils, AStar64.FileStructs, Geo.Hash, Geo.Pos, AStar64.Typ,
SysUtils, Classes, UFiles, {Windows, }Ils.Logger, System.IniFiles,
System.Generics.Collections, System.Math, AStar64.Files, AStar64.Areas,
AStar64.Extra, uGeneral, Geo.Calcs, LandmarkPathCalculator, AStar64.LandMark,
System.Types;
const
// CAreaFile = 'Areas.txt';
CHashChars: string = '0123456789bcdefghjkmnpqrstuvwxyz';
PathDelim = '\';
type
{ TLandMarkWayKey = packed record
v: THashVector; //16
z: UInt64; //24
end;
TLandMarkIdxFileRecord = packed record
k: TLandMarkWayKey; //24
i: Int64; //32
end;
TWayLen = packed record
Way: string;
Len: Double;
end;
TLandMarkIdxLenFileRecord = packed record
k: TLandMarkWayKey; //24
i: Int64; //32
l: Double; //40
RESERVED: Int64; //48
end;
}
{ TAreaStateType = (stNoCalc, stPartialCalc, stInCalc, stFullCalc);
TWayLen = packed record
Way: string;
Len: Double;
end;
TZoneTrackDictionary = TDictionary<UInt64, TWayLen>;
TLandMarkDictionary = TDictionary<THashVector, TZoneTrackDictionary>;
TLandMarkAreaInfo = record
// ID: Integer;
AccountID: Integer;
State: TAreaStateType; //состояние рассчитанности маршрутов
//0 не рассчитано, 1 частично рассчитано, 2 в процессе расчета, 3 рассчитано
// Color: Integer;
GeoHashID: string;
Name: string;
PolygonHash: string;
LandMarksHash: string;
Polygon: TGeoPosArray;
LandMarks: TGeoPosArray;
LandMarkDict: TLandMarkDictionary;
end;
TLandMarkAreaDictionary = TDictionary<Integer, TLandMarkAreaInfo>;}
TLandMarkArea = class
private
FDetailLog: Boolean;
FRequestNo: Cardinal;
public
constructor Create(const ARequestNo: Cardinal; const ADetailLog: Boolean = False); overload;
destructor Destroy(); override;
class procedure Stop;
function LoadOneAreaFile(const ARootPath: string; const AAccount: integer; const ADetailLog: Boolean = false): TLandMarkAreaDictionary;
function LoadAreaFile(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const ADetailLog: Boolean = false): TLandMarkAreaDictionary;
function LoadAreaFileMini(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const ADetailLog: Boolean = false): TLandMarkAreaDictionary;
function SaveAreas(const ARootPath: string;
const AAccount: integer;
const AAreas: TLandMarkAreaDictionary;
const ASaveTracks: Boolean;
const ADetailLog: Boolean = false): Boolean;
function SaveLandMarks(const ARootPath: string; const AAccount: integer; const AGeoHashID: string; ALandMarkDict: TLandMarkDictionary): Boolean;
function GetAreas(ALandMarkAreaDict: TLandMarkAreaDictionary): TJsonObject;
function GetAreasStateOk(ALandMarkAreaDict: TLandMarkAreaDictionary): TJsonObject;
function GetLandMarks(const APolygon: string; const ADistKm: double = 0): TGeoPosArray;
function GetLandMarksJson(const ALandMarks: string): TJsonObject;
{ function GetPointsForCalc(AAreaInfo: TLandMarkAreaInfo;
const AAreaID: Integer;
const ADetailLog: Boolean = false): TLandMarkMatrix;}
function GetAreaTracks(const ARootPath: string;
const AAccount: Integer;
const AGeoHashID: string;
const ADetailLog: Boolean = false): TLandMarkDictionary;
function CalcTrackFiles(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const AAreaID: Integer;
const AThreads: Integer;
const AFullCalc: Boolean = False;
const ADetailLog: Boolean = false): Boolean;
function DelTrackFiles(const ARootPath: string;
const AAccount: Integer;
const AGeoHashID: string;
const ADetailLog: Boolean = false): Boolean;
function CompareAreas(const ARootPath: string;
const AAccounts: TIntegerDynArray;
AAreaInfoOld, AAreaInfoNew: TLandMarkAreaInfo): TLandMarkAreaInfo;
function LM2GW(AWay: string): string;
function GetAreaIDFromGeoHashID(const ARootPath: string;
const AAccounts: TIntegerDynArray; AGeoHashID: string): Integer;
function CheckRouteInTrack(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const ARoutePoints: TGeoPosArray;
var AAreas: TLandMarkAreaDictionary;
const ADetailLog: Boolean = false): Boolean;
function CheckRouteInRoute(const ARoute1, ARoute2: TGeoPosArray): Boolean;
{ function LoadOneZoneFile(AAccount: integer; ADetailLog: Boolean = false): TZoneDictionary;
function LoadOneZoneTypeFile(AAccount: integer; ADetailLog: Boolean = false): TZoneTypeDictionary;
function LoadZoneFile(const ARootPath: string;
const AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): TJsonObject;
function LoadZoneTypeFile(AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): TJsonObject;
function LoadProgress(AAccount: integer; ADetailLog: Boolean = false): Integer;
procedure SaveProgress(AAccount: integer);
function GetCorrectBorder(ABorder: TGeoPosArray): TGeoPosArray;
function SaveZones(AAccount: integer; AZones: TZoneDictionary; ADetailLog: Boolean = false): Boolean;
function SaveZoneTypes(AAccount: integer; AZoneTypes: TZoneTypeDictionary; ADetailLog: Boolean = false): Boolean;
function GetFilesNameArray(ATopLeft, ABottomRight: TGeoPos; ADetailLog: Boolean = false): TFileNameArray;
function GetFilesNameArrayHash(TopLeftHash, BottomRightHash : int64; ADetailLog: Boolean = false): TFileNameArray;
function CheckFilesExists(const ARootPath: string;
const AAccount: Integer;
const AHash: string; ADetailLog: Boolean = false
): boolean;
function CheckFilesExists1(const ARootPath: string;
const AAccount: Integer;
const AHash: string; ADetailLog: Boolean = false
): boolean;
function CheckFilesExists2(const ARootPath: string;
const AAccount: Integer;
const AHash: string
): boolean;
function GetCoverZones(const ABounds: string;
const AAccounts: TIntegerDynArray;
const ARootPath: string;
const ADepth: integer = -1; ADetailLog: Boolean = false): TJsonObject;
function PatchZoneHash(AHash: string): string;
function CheckArea(const AArea: TGeoPosArray;const APoint: TGeoPos; ADetailLog: Boolean = false): Boolean;
function CheckRouteInThroughArea(const AZone: TGeoPosArray; const ARoutePoints: TGeoPosArray; ADetailLog: Boolean = false): Boolean;
function Intersection(const APoint1, APoint2, BPoint1, BPoint2: TGeoPos):boolean;
function ZCPlaceIsEmpty(AZCPlace: TArray<UInt64>): Boolean;
function ScanForAll(AAccounts: TIntegerDynArray): Boolean; //старый код, не используется
procedure ParseZones();
function SaveOneZC(AEdgeFileName, AZCFileName: string): Boolean;
function SaveTwoZC(const ARootPath: string;
const AAccounts: TIntegerDynArray;
AFileName: string): Boolean;
function SaveAllZC(const ARootPath: string;
const AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): Boolean;
function SaveFileListZC(const ARootPath: string;
const ATopLeft, ABottomRight: TGeoPos;
const AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): Boolean;
function DeleteAllZC(const ARootPath: string;
const AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): Boolean;
function FillFileNameArray: integer;
function CreateZCAll(const ARootPath: string;
const AAccounts: TIntegerDynArray; ADetailLog: Boolean = false): Boolean;
function CopyFilesForZone(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const AZoneName: string; ADetailLog: Boolean = false): Boolean;}
end;
implementation
{ TLandMarkArea }
function TLandMarkArea.CalcTrackFiles(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const AAreaID: Integer;
const AThreads: Integer;
const AFullCalc: Boolean;
const ADetailLog: Boolean): Boolean;
var
AreaInfo: TLandMarkAreaInfo;
LandMarkMatrix: TLandMarkMatrix;
Areas: TLandMarkAreaDictionary;
// K: TLandMarkWayKey;
// LMWay: TLandMarkWay;
// WayLen: TWayLen;
// ZoneTrackDict: TZoneTrackDictionary;
iForRecalc: Integer;
FileName: string;
begin
Result := True;
Areas := LoadAreaFile(ARootPath, AAccounts, ADetailLog);
if Areas.TryGetValue(AAreaID, AreaInfo) then
begin
AreaInfo.State := stInCalc;
Areas.AddOrSetValue(AAreaID, AreaInfo);
SaveAreas(ARootPath, AAccounts[0], Areas, False);
if Length(AreaInfo.GeoHashID) = 26 then
FileName := Copy(AreaInfo.GeoHashID,3,12)+'_'+Copy(AreaInfo.GeoHashID,15,12);
ToLog('Request # ' + IntToStr(FRequestNo) + ' TLandMarkArea.CalcTrackFiles. Set to stInCalc. ID='+IntToStr(AAreaID));
// LandMarkMatrix := GetPointsForCalc(AreaInfo, AAreaID, ADetailLog);
// ToLog('Request # ' + IntToStr(FRequestNo) + ' TLandMarkArea.CalcTrackFiles. Need calc vectors = '+IntToStr(LandMarkMatrix.Count));
// TLPC.GetCalcMulti(ARootPath, AAccounts, nil, AThreads, TGeneral.FLandMarkCalcTimeout, LandMarkMatrix);
TLPC.GenMulti(ARootPath, FileName,
AreaInfo.LandMarks, AAccounts, nil, AThreads,
TGeneral.FLandMarkCalcTimeout, AFullCalc);
LandMarkMatrix := TLandMarkMatrix.Create(ARootPath+IntToStr(AAccounts[0])+'\', FileName, AAccounts, IntToStr(AAccounts[0]));
LandMarkMatrix.LoadIndex;
{ for K in LandMarkMatrix.Keys do
begin
if LandMarkMatrix.TryGetValue(K, LMWay) then
begin
if not AreaInfo.LandMarkDict.TryGetValue(K.v, ZoneTrackDict) then
ZoneTrackDict := TDictionary<UInt64, TWayLen>.Create;
WayLen.Len := LMWay.Distance;
WayLen.Way := LMWay.GeoHash;
ZoneTrackDict.AddOrSetValue(K.z, WayLen);
AreaInfo.LandMarkDict.AddOrSetValue(K.v, ZoneTrackDict);
end;
end;
SaveLandMarks(ARootPath, AAccounts[0], AreaInfo.GeoHashID, AreaInfo.LandMarkDict);
LandMarkMatrix := GetPointsForCalc(AreaInfo, AAreaID, ADetailLog);}
iForRecalc := Length(LandMarkMatrix.GetKeysForRecalc);
ToLog('Request # ' + IntToStr(FRequestNo) + ' TLandMarkArea.CalcTrackFiles. After calc. Need calc vectors = '+IntToStr(iForRecalc));
if iForRecalc = 0 then
AreaInfo.State := stFullCalc
else
AreaInfo.State := stPartialCalc;
Areas.AddOrSetValue(AAreaID, AreaInfo);
SaveAreas(ARootPath, AAccounts[0], Areas, False);
end;
end;
function TLandMarkArea.CheckRouteInRoute(const ARoute1,
ARoute2: TGeoPosArray): Boolean;
var
i, j: Integer;
begin
Result := False;
for I := Low(ARoute1) to High(ARoute1) do
for J := Low(ARoute2) to High(ARoute2) do
if ARoute1[i] = ARoute2[j] then
Exit(True);
end;
function TLandMarkArea.CheckRouteInTrack(const ARootPath: string;
const AAccounts: TIntegerDynArray;
const ARoutePoints: TGeoPosArray;
var AAreas: TLandMarkAreaDictionary;
const ADetailLog: Boolean = false): Boolean;
var
HashVector: THashVector;
AreaID: Integer;
AreaInfo: TLandMarkAreaInfo;
ZoneTrack: TZoneTrackDictionary;
WayLen: TWayLen;
Zone: UInt64;
TrackPoints: TGeoPosArray;
DeleteVectors: TDictionary<THashVector,Integer>;
NeedSave: Boolean;
begin
DeleteVectors := TDictionary<THashVector,Integer>.Create;
NeedSave := False;
try
for AreaID in AAreas.Keys do
begin
AAreas.TryGetValue(AreaID, AreaInfo);
DeleteVectors.Clear;
for HashVector in AreaInfo.LandMarkDict.Keys do
begin
AreaInfo.LandMarkDict.TryGetValue(HashVector, ZoneTrack);
for Zone in ZoneTrack.Keys do
begin
ZoneTrack.TryGetValue(Zone, WayLen);
TGeoHash.DecodeArrayWorld(WayLen.Way, TrackPoints);
//выясняем какие треки пересекаются с дорогой и удаляем их вектора
if CheckRouteInRoute(ARoutePoints, TrackPoints) then
DeleteVectors.AddOrSetValue(HashVector, 0);
end;
end;
//меняем статус региона если что-то удаляем
if DeleteVectors.Count > 0 then
begin
NeedSave := True;
if AreaInfo.State = stFullCalc then
AreaInfo.State := stPartialCalc;
//удаляем вектора
for HashVector in DeleteVectors.Keys do
AreaInfo.LandMarkDict.Remove(HashVector);
AAreas.AddOrSetValue(AreaID, AreaInfo);
end;
end;
Result := NeedSave;
finally
DeleteVectors.Free;
end;
end;
function TLandMarkArea.CompareAreas(const ARootPath: string;
const AAccounts: TIntegerDynArray;
AAreaInfoOld, AAreaInfoNew: TLandMarkAreaInfo): TLandMarkAreaInfo;
var
i, j: Integer;
// HashVector: THashVector;
LMDictOld, LMDictNew,
AddedPoints, DeletedPoints: TDictionary<TGeoPos,Integer>;
DeleteHashVector, AddHashVector: TDictionary<THashVector,Integer>;
HashVector: THashVector;
Point: TGeoPos;
FilenameOld, FilenameNew: string;
LMMatrixOld, LMMatrixNew : TLandMarkMatrix;
LMKey: TLandMarkWayKey;
LMWay: TLandMarkWay;
begin
//сверяем маяки
Result := AAreaInfoNew;
LMDictOld := TDictionary<TGeoPos,Integer>.Create;
LMDictNew := TDictionary<TGeoPos,Integer>.Create;
AddedPoints := TDictionary<TGeoPos,Integer>.Create;
DeletedPoints := TDictionary<TGeoPos,Integer>.Create;
DeleteHashVector := TDictionary<THashVector,Integer>.Create;
AddHashVector := TDictionary<THashVector,Integer>.Create;
try
TGeoHash.DecodeArrayWorld(AAreaInfoOld.LandMarksHash, AAreaInfoOld.LandMarks);
TGeoHash.DecodeArrayWorld(AAreaInfoNew.LandMarksHash, AAreaInfoNew.LandMarks);
for I := Low(AAreaInfoOld.LandMarks) to High(AAreaInfoOld.LandMarks) do
LMDictOld.AddOrSetValue(AAreaInfoOld.LandMarks[i], 0);
for I := Low(AAreaInfoNew.LandMarks) to High(AAreaInfoNew.LandMarks) do
LMDictNew.AddOrSetValue(AAreaInfoNew.LandMarks[i], 0);
for Point in LMDictOld.Keys do
begin
if not LMDictNew.TryGetValue(Point, j) then
DeletedPoints.AddOrSetValue(Point, 0);
end;
for Point in LMDictNew.Keys do
begin
if not LMDictOld.TryGetValue(Point, j) then
AddedPoints.AddOrSetValue(Point, 0);
end;
FilenameOld := Copy(AAreaInfoOld.GeoHashID,3,12)+'_'+Copy(AAreaInfoOld.GeoHashID,15,12);
LMMatrixOld := TLandMarkMatrix.Create(ARootPath,FilenameOld,AAccounts, IntToStr(AAccounts[0]));
LMMatrixOld.LoadIndex;
FilenameNew := Copy(AAreaInfoNew.GeoHashID,3,12)+'_'+Copy(AAreaInfoNew.GeoHashID,15,12);
if FilenameNew <> FilenameOld then
LMMatrixNew := TLandMarkMatrix.Create(ARootPath,FilenameNew,AAccounts, IntToStr(AAccounts[0]))
else
LMMatrixNew := LMMatrixOld;
Result := AAreaInfoNew;
Result.LandMarkDict := AAreaInfoOld.LandMarkDict;
Result.State := AAreaInfoOld.State;
if DeletedPoints.Count <> 0 then
begin
for Point in DeletedPoints.Keys do
begin
for HashVector in Result.LandMarkDict.Keys do
begin
if HashVector.HashFrom = Point.ToHash then
DeleteHashVector.AddOrSetValue(HashVector, 0);
if HashVector.HashTo = Point.ToHash then
DeleteHashVector.AddOrSetValue(HashVector, 0);
end;
//удалились маяки, удаляем их треки
for LMKey in LMMatrixOld.Keys do
begin
if LMKey.v.HashFrom = Point.ToHash then
LMMatrixNew.Remove(LMKey);
if LMKey.v.HashTo = Point.ToHash then
LMMatrixNew.Remove(LMKey);
end;
end;
//удаляем старые файлы с треками
if AAreaInfoOld.GeoHashID <> AAreaInfoNew.GeoHashID then
DelTrackFiles(ARootPath, AAccounts[0], AAreaInfoOld.GeoHashID, FDetailLog);
for HashVector in DeleteHashVector.Keys do
begin
Result.LandMarkDict.Remove(HashVector);
end;
{ Result.LandMarkDict := AAreaInfoOld.LandMarkDict;
for HashVector in Result.LandMarkDict.Keys do
begin
if DeletedPoints.TryGetValue(HashVector.PointFrom, j) then
DeleteHashVector.AddOrSetValue(HashVector, 0);
if DeletedPoints.TryGetValue(HashVector.PointTo, j) then
DeleteHashVector.AddOrSetValue(HashVector, 0);
end;
for HashVector in DeleteHashVector.Keys do
begin
Result.LandMarkDict.Remove(HashVector);
end;
//удаляем старые файлы с треками
DelTrackFiles(ARootPath, AAccounts[0], AAreaInfoOld.GeoHashID, FDetailLog);}
end;
if AddedPoints.Count <> 0 then
begin
//Добавились маяки, понижаем статус
if Result.State = stFullCalc then
Result.State := stPartialCalc;
for Point in AddedPoints.Keys do
begin
for I := Low(Result.LandMarks) to High(Result.LandMarks) do
begin
if Point.ToHash <> Result.LandMarks[i].ToHash then
begin
LMKey.z := 0;
LMWay := TLandMarkWay.Create('fullcalc',0);
LMKey.v.HashFrom := Point.ToHash;
LMKey.v.HashTo := Result.LandMarks[i].ToHash;
LMMatrixNew.AddOrSetValue(LMKey, LMWay);
LMKey.z := 0;
LMWay := TLandMarkWay.Create('fullcalc',0);
LMKey.v.HashTo := Point.ToHash;
LMKey.v.HashFrom := Result.LandMarks[i].ToHash;
LMMatrixNew.AddOrSetValue(LMKey, LMWay);
HashVector.HashFrom := Point.ToHash;
HashVector.HashTo := Result.LandMarks[i].ToHash;
AddHashVector.AddOrSetValue(HashVector, 0);
HashVector.HashTo := Point.ToHash;
HashVector.HashFrom := Result.LandMarks[i].ToHash;
AddHashVector.AddOrSetValue(HashVector, 0);
end;
end;
end;
for HashVector in AddHashVector.Keys do
Result.LandMarkDict.AddOrSetValue(HashVector, TDictionary<UInt64, TWayLen>.Create);
end;
LMMatrixNew.Save;
finally
LMDictOld.Free;
LMDictNew.Free;
AddedPoints.Free;
DeletedPoints.Free;
DeleteHashVector.Free;
AddHashVector.Free;
end;
end;
constructor TLandMarkArea.Create(const ARequestNo: Cardinal; const ADetailLog: Boolean);
begin
FDetailLog := ADetailLog;
FRequestNo := ARequestNo;
// FLandMarkAreaDictionary := TDictionary<Integer, TLandMarkAreaInfo>.Create;
if FDetailLog then
ToLog('TLandMarkArea Start');
end;
function TLandMarkArea.DelTrackFiles(const ARootPath: string;
const AAccount: Integer; const AGeoHashID: string;
const ADetailLog: Boolean): Boolean;
var
FileName: string;
FullPath: string;
begin
FileName := Copy(AGeoHashID,3,12) + '_' + Copy(AGeoHashID,15,12);
FullPath := ARootPath + IntToStr(AAccount) + PathDelim;
if not (FileExists(FullPath + FileName + CDataFileExt) and
FileExists(FullPath + FileName + CIndexFileExt) and
FileExists(FullPath + FileName + CRecalcFileExt)) then
Exit(True);
Result := DeleteFile(PChar(FullPath + FileName + CDataFileExt)) and
DeleteFile(PChar(FullPath + FileName + CIndexFileExt)) and
DeleteFile(PChar(FullPath + FileName + CRecalcFileExt));
end;
destructor TLandMarkArea.Destroy;
begin
// FLandMarkAreaDictionary.Free;
if FDetailLog then
ToLog('TLandMarkArea Stop');
inherited;
end;
function TLandMarkArea.GetAreaIDFromGeoHashID(const ARootPath: string;
const AAccounts: TIntegerDynArray; AGeoHashID: string): Integer;
var
AreasDict: TLandMarkAreaDictionary;
AreaInfo: TLandMarkAreaInfo;
ID: Integer;
begin
Result := -1;
AreasDict := LoadAreaFileMini(ARootPath, AAccounts);
for ID in AreasDict.Keys do
begin
if AreasDict.TryGetValue(ID, AreaInfo) then
begin
if AreaInfo.GeoHashID = AGeoHashID then
Exit(ID);
end;
end;
end;
function TLandMarkArea.GetAreas(ALandMarkAreaDict: TLandMarkAreaDictionary): TJsonObject;
var
AreaInfo: TLandMarkAreaInfo;
HashVector: THashVector;
ZoneTrackDict: TZoneTrackDictionary;
Zone: UInt64;
Way: TWayLen;
Points: TGeoPosArray;
ID: Integer;
begin
Result := TJsonObject.Create;
for ID in ALandMarkAreaDict.Keys do
begin
ALandMarkAreaDict.TryGetValue(ID, AreaInfo);
with Result.A['Areas'].AddObject do
begin
I['ID'] := ID;
I['AccountID'] := AreaInfo.AccountID;
I['State'] := Integer(AreaInfo.State);
S['Name'] := AreaInfo.Name;
S['GeoHashID'] := AreaInfo.GeoHashID;
S['Polygon'] := AreaInfo.PolygonHash;
S['LandMarks'] := AreaInfo.LandMarksHash;
if Assigned(AreaInfo.LandMarkDict) then
for HashVector in AreaInfo.LandMarkDict.Keys do
begin
AreaInfo.LandMarkDict.TryGetValue(HashVector, ZoneTrackDict);
for Zone in ZoneTrackDict.Keys do
begin
ZoneTrackDict.TryGetValue(Zone, Way);
SetLength(Points, 2);
Points[0] := HashVector.PointFrom;
Points[1] := HashVector.PointTo;
with A['Tracks'].AddObject do
begin
S['Points'] := TGeoHash.EncodeArrayWorld(Points, gfPointsArray);
S['Zone'] := UIntToStr(Zone);
S['Way'] := LM2GW(Way.Way);
end;
end;
end;
end;
end;
end;
function TLandMarkArea.GetAreasStateOk(
ALandMarkAreaDict: TLandMarkAreaDictionary): TJsonObject;
var
AreaInfo: TLandMarkAreaInfo;
ID: Integer;
begin
Result := TJsonObject.Create;
Result.S['Result'] := 'Ok';
for ID in ALandMarkAreaDict.Keys do
begin
ALandMarkAreaDict.TryGetValue(ID, AreaInfo);
with Result.A['Areas'].AddObject do
begin
I['ID'] := ID;
I['State'] := Integer(AreaInfo.State);
end;
end;
end;
function TLandMarkArea.GetAreaTracks(const ARootPath: string;
const AAccount: Integer;
const AGeoHashID: string;
const ADetailLog: Boolean): TLandMarkDictionary;
var
LandMarkArr: array of TLandMarkIdxLenFileRecord;
IdxFile, DatFile: TFileStream;
DatFileReader: TStreamReader;
IdxFileName, DatFileName, FileName: string;
i: Integer;
Way: TWayLen;
ZoneTrackDict: TZoneTrackDictionary;
begin
Result := TDictionary<THashVector, TZoneTrackDictionary>.Create;
begin
FileName := Copy(AGeoHashID,3,12) + '_' + Copy(AGeoHashID,15,12);
IdxFileName := ARootPath + IntToStr(AAccount) + PathDelim + FileName + '.idx';
DatFileName := ARootPath + IntToStr(AAccount) + PathDelim + FileName + '.dat';
if not (FileExists(IdxFileName) and FileExists(DatFileName)) then
Exit;
IdxFile := TFileStream.Create(IdxFileName, fmOpenRead and fmShareDenyNone);
DatFile := TFileStream.Create(DatFileName, fmOpenRead and fmShareDenyNone);
DatFileReader := TStreamReader.Create(DatFile, TEncoding.ANSI, True);
try
SetLength(LandMarkArr, IdxFile.Size div SizeOf(TLandMarkIdxLenFileRecord));
IdxFile.ReadBuffer(LandMarkArr[0], IdxFile.Size);
for i := Low(LandMarkArr) to High(LandMarkArr) do
begin
// LandMark := LandMarkArr[i];
if (LandMarkArr[i].k.v.HashFrom > 0) and (LandMarkArr[i].k.v.HashTo > 0) and (LandMarkArr[i].i < DatFile.Size) then
begin
DatFileReader.DiscardBufferedData;
DatFile.Position := LandMarkArr[i].i;
Way.Way := Trim(DatFileReader.ReadLine);
Way.Len := 0;
// TGeoHash.DecodeArrayWorld(s, Points);
// s := TGeoHash.EncodeArrayWorld(Points);
if not Result.TryGetValue(LandMarkArr[i].k.v, ZoneTrackDict) then
ZoneTrackDict := TDictionary<UInt64, TWayLen>.Create;
ZoneTrackDict.AddOrSetValue(LandMarkArr[i].k.z, Way);
Result.AddOrSetValue(LandMarkArr[i].k.v, ZoneTrackDict);
end;
end;
finally
IdxFile.Free;
DatFileReader.Free;
DatFile.Free;
end;
end;
end;
function TLandMarkArea.GetLandMarks(const APolygon: string; const ADistKm: double): TGeoPosArray;
var
Points, PointsCalc: TGeoPosArray;
i, j, k: Integer;
Distance, LatitudeInc, LongitudeInc: Double;
NeedSection: integer;
begin
SetLength(Result, 0);
Exit;
// Result := TJsonObject.Create;
TGeoHash.DecodeArrayWorld(APolygon, Points);
if ADistKm = 0 then
begin
//возвращаем точки полигона (прямоугольника)
Result := Points;
// s := TGeoHash.EncodeArrayWorld(Points, 'PA');
// Result.S['LandMarks'] := s;
end else
begin
//рассчитываем расстояния между точками не больше ADistKm
i := 1;
j := 1;
SetLength(PointsCalc,1);
PointsCalc[0] := Points[0];
while i < Length(Points) do
begin
Distance := TGeoCalcs.GeoLengthKmDeg(Points[i-1], Points[i]);
if Distance > ADistKm then
begin
NeedSection := trunc(Distance/ADistKm)+1;
LatitudeInc := (Points[i].Latitude-Points[i-1].Latitude)/NeedSection;
LongitudeInc := (Points[i].Longitude-Points[i-1].Longitude)/NeedSection;
for k := 1 to NeedSection-1 do
begin
SetLength(PointsCalc, Length(PointsCalc)+1);
PointsCalc[j].Latitude := Points[i-1].Latitude + LatitudeInc*k;
PointsCalc[j].Longitude := Points[i-1].Longitude + LongitudeInc*k;
inc(j);
end;
SetLength(PointsCalc, Length(PointsCalc)+1);
PointsCalc[j] := Points[i];
inc(j);
end else
begin
SetLength(PointsCalc, Length(PointsCalc)+1);
PointsCalc[j] := Points[i];
inc(j);
end;
inc(i);
end;
//если полигон незамкнутый, то обрабатываем между первой и последней
if Low(Points) <> High(Points) then
begin
Distance := TGeoCalcs.GeoLengthKmDeg(Points[0], Points[High(Points)]);
if Distance > ADistKm then
begin
NeedSection := trunc(Distance/ADistKm)+1;
LatitudeInc := (Points[0].Latitude-Points[High(Points)].Latitude)/NeedSection;
LongitudeInc := (Points[0].Longitude-Points[High(Points)].Longitude)/NeedSection;
for k := 1 to NeedSection-1 do
begin
SetLength(PointsCalc, Length(PointsCalc)+1);
PointsCalc[High(PointsCalc)].Latitude := Points[High(Points)].Latitude + LatitudeInc*k;
PointsCalc[High(PointsCalc)].Longitude := Points[High(Points)].Longitude + LongitudeInc*k;
end;
end;
end;
Result := PointsCalc;
end;
end;
function TLandMarkArea.GetLandMarksJson(const ALandMarks: string): TJsonObject;
begin
Result := TJsonObject.Create;
Result.S['LandMarks'] := ALandMarks;
end;
(*function TLandMarkArea.GetPointsForCalc(AAreaInfo: TLandMarkAreaInfo;
const AAreaID: Integer;
const ADetailLog: Boolean): TLandMarkMatrix;
var
ZoneTrack: TZoneTrackDictionary;
// AreaInfo: TLandMarkAreaInfo;
K: TLandMarkWayKey;
i,j: Integer;
begin
//загружаем все маяки, сверяем маяки и имеющиеся треки, выводим недостающие вектора
// Result := TLandMarkMatrix.Create(ARootPath, '');
Result := TLandMarkMatrix.Create('', '', FAccounts);
TGeoHash.DecodeArrayWorld(AAreaInfo.LandMarksHash, AAreaInfo.LandMarks);
K.z := 0;
for I := Low(AAreaInfo.LandMarks) to High(AAreaInfo.LandMarks) do
begin
for J := Low(AAreaInfo.LandMarks) to High(AAreaInfo.LandMarks) do
begin
if (I = J) then
Continue;
K.v.HashFrom := AAreaInfo.LandMarks[I].ToHash;
K.v.HashTo := AAreaInfo.LandMarks[J].ToHash;
if AAreaInfo.LandMarkDict.TryGetValue(K.v, ZoneTrack) then
Continue;
if not Result.ContainsKey(K) then
Result.Add(K, TLandMarkWay.Create('', 0))
end;
end;
end;
*)
function TLandMarkArea.LoadAreaFile(const ARootPath: string;
const AAccounts: TIntegerDynArray; const ADetailLog: Boolean): TLandMarkAreaDictionary;
var
AreaInfo: TLandMarkAreaInfo;
ID: Integer;
{ AreaList: TStringList;
sHashID, sFileName: string;
I, j: Integer;
Json: TJsonObject;}
begin
Result := LoadAreaFileMini(ARootPath, AAccounts, ADetailLog);
for ID in Result.Keys do
begin
Result.TryGetValue(ID, AreaInfo);
AreaInfo.LandMarkDict := GetAreaTracks(ARootPath, AreaInfo.AccountID, AreaInfo.GeoHashID, ADetailLog);
Result.AddOrSetValue(ID, AreaInfo);
end;
// Result := False;
{ Json := TJsonObject.Create;
AreaList := TStringList.Create();
try
for j := High(AAccounts) downto 0 do
begin
sFileName := ARootPath + IntToStr(AAccounts[j]) + PathDelim + CAreaFile;
if FileExists(sFileName) then
begin
AreaInfo.AccountID := AAccounts[j];
AreaList.LoadFromFile(sFileName);
Json := TJsonObject(TJsonObject.Parse(AreaList.Text));
for i := 0 to json.A['Areas'].Count - 1 do
begin
ID := json.A['Areas'].O[i].I['ID'];
AreaInfo.Name := json.A['Areas'].O[i].S['GeoHashID'];
AreaInfo.Name := json.A['Areas'].O[i].S['Name'];
AreaInfo.PolygonHash := json.A['Areas'].O[i].S['Polygon'];
AreaInfo.LandMarksHash := json.A['Areas'].O[i].S['LandMarks'];
TGeoHash.DecodeArrayWorld(AreaInfo.PolygonHash, AreaInfo.Polygon);
TGeoHash.DecodeArrayWorld(AreaInfo.LandMarksHash, AreaInfo.LandMarks);
AreaInfo.LandMarkDict := GetAreaTracks(ARootPath, AreaInfo.AccountID, sHashID, ADetailLog);
FLandMarkAreaDictionary.AddOrSetValue(ID, AreaInfo);
end;
end;
end;
Result := True;
finally
AreaList.Free();
Json.Free;
end;}
end;
function TLandMarkArea.LoadAreaFileMini(const ARootPath: string;
const AAccounts: TIntegerDynArray; const ADetailLog: Boolean): TLandMarkAreaDictionary;
var
AreaList: TStringList;
sFileName: string;
I, j, ID: Integer;
AreaInfo: TLandMarkAreaInfo;
Json: TJsonObject;
begin
// Result := False;
Result := TLandMarkAreaDictionary.Create;//<Integer, TLandMarkAreaInfo>.Create;
Json := TJsonObject.Create;
AreaList := TStringList.Create();
try
for j := High(AAccounts) downto 0 do
begin
sFileName := ARootPath + IntToStr(AAccounts[j]) + PathDelim + CAreaFile;
if FileExists(sFileName) then
begin
AreaInfo.AccountID := AAccounts[j];
AreaList.LoadFromFile(sFileName);
Json := TJsonObject(TJsonObject.Parse(AreaList.Text));
for i := 0 to json.A['Areas'].Count - 1 do
begin
ID := json.A['Areas'].O[i].I['ID'];
AreaInfo.State := TAreaStateType(json.A['Areas'].O[i].I['State']);
AreaInfo.GeoHashID := json.A['Areas'].O[i].S['GeoHashID'];
AreaInfo.Name := json.A['Areas'].O[i].S['Name'];
AreaInfo.PolygonHash := json.A['Areas'].O[i].S['Polygon'];
AreaInfo.LandMarksHash := json.A['Areas'].O[i].S['LandMarks'];
TGeoHash.DecodeArrayWorld(AreaInfo.PolygonHash, AreaInfo.Polygon);
TGeoHash.DecodeArrayWorld(AreaInfo.LandMarksHash, AreaInfo.LandMarks);
AreaInfo.LandMarkDict := nil;
// AreaInfo.LandMarkDict := GetAreaTracks(ARootPath, AreaInfo.AccountID, sHashID, ADetailLog);
Result.AddOrSetValue(ID, AreaInfo);
end;
end;
end;
// Result := True;
finally
AreaList.Free();
Json.Free;
end;
end;
function TLandMarkArea.LoadOneAreaFile(const ARootPath: string; const AAccount: integer;
const ADetailLog: Boolean): TLandMarkAreaDictionary;
var
AreaList: TStringList;
sFileName: string;
i, ID: Integer;
AreaInfo: TLandMarkAreaInfo;
Json: TJsonObject;
begin
Result := TLandMarkAreaDictionary.Create;//<Integer, TLandMarkAreaInfo>.Create;
AreaList := TStringList.Create();
Json := TJsonObject.Create;
try
sFileName := ARootPath + IntToStr(AAccount) + PathDelim + CAreaFile;
if FileExists(sFileName) then
begin
AreaInfo.AccountID := AAccount;
AreaList.LoadFromFile(sFileName);
Json := TJsonObject(TJsonObject.Parse(AreaList.Text));
for i := 0 to json.A['Areas'].Count - 1 do
begin
ID := json.A['Areas'].O[i].I['ID'];
AreaInfo.GeoHashID := json.A['Areas'].O[i].S['GeoHashID'];
AreaInfo.Name := json.A['Areas'].O[i].S['Name'];
AreaInfo.PolygonHash := json.A['Areas'].O[i].S['Polygon'];
AreaInfo.LandMarksHash := json.A['Areas'].O[i].S['LandMarks'];
TGeoHash.DecodeArrayWorld(AreaInfo.PolygonHash, AreaInfo.Polygon);
TGeoHash.DecodeArrayWorld(AreaInfo.LandMarksHash, AreaInfo.LandMarks);
Result.AddOrSetValue(ID, AreaInfo);
end;
{ if FileExists(sFileName) then
begin
AreaInfo.AccountID := AAccount;
AreaList.LoadFromFile(sFileName);
for I := 0 to AreaList.Count - 1 do
begin
if TGeneral.FStop then
begin
ToLog('Request # '+ IntToStr(FRequestNo) + ' TLandMarkArea.LoadOneAreaFile. Прервано пользователем');
Exit;
end;
TempStr := AreaList[I];
// ID
TabPos := Pos(#9, TempStr);
sHashID := Copy(TempStr, 1, TabPos - 1);
Delete(TempStr, 1, TabPos);
// _имя
TabPos := Pos(#9, TempStr);
AreaInfo.Name := Copy(TempStr, 1, TabPos - 1);
Delete(TempStr, 1, TabPos);
// _Polygon
TabPos := Pos(#9, TempStr);
AreaInfo.PolygonHash := Copy(TempStr, 1, TabPos - 1);
Delete(TempStr, 1, TabPos);
// LandMark
AreaInfo.LandMarksHash := TempStr;
TGeoHash.DecodeArrayWorld(AreaInfo.PolygonHash, AreaInfo.Polygon);
TGeoHash.DecodeArrayWorld(AreaInfo.LandMarksHash, AreaInfo.LandMarks);
Result.AddOrSetValue(sHashID, AreaInfo);
end;}
end;
finally
AreaList.Free();
Json.Free();
end;
end;
function TLandMarkArea.SaveAreas(const ARootPath: string; const AAccount: integer;
const AAreas: TLandMarkAreaDictionary;
const ASaveTracks: Boolean;
const ADetailLog: Boolean): Boolean;
var
List, LmdList: TStringList;
ID, j: Integer;
AreaInfo: TLandMarkAreaInfo;
RootDir, AccDir: string;
Json: TJsonObject;
begin
Json := TJsonObject.Create;
try
List := TStringList.Create;
try
for ID in AAreas.Keys do
begin
try
LmdList := TStringList.Create;
AAreas.TryGetValue(ID, AreaInfo);
with Json.A['Areas'].AddObject do
begin
I['ID'] := ID;
S['Name'] := AreaInfo.Name;
S['GeoHashID'] := AreaInfo.GeoHashID;
I['State'] := Integer(AreaInfo.State);
S['Polygon'] := AreaInfo.PolygonHash;
S['LandMarks'] := AreaInfo.LandMarksHash;
for j := Low(AreaInfo.LandMarks) to High(AreaInfo.LandMarks) do
LmdList.Add(FloatToStr(AreaInfo.LandMarks[j].Latitude, TGeneral.Ffs) + #9 + FloatToStr(AreaInfo.LandMarks[j].Longitude, TGeneral.Ffs));
LmdList.SaveToFile(ARootPath+IntToStr(AAccount)+'\'+AreaInfo.Name+'.lmd');
if ASaveTracks and Assigned(AreaInfo.LandMarkDict) and (AreaInfo.LandMarkDict.Count > 0) then
begin
SaveLandMarks(ARootPath, AAccount, AreaInfo.GeoHashID, AreaInfo.LandMarkDict);
end;
end;
finally
LmdList.Free;
end;
end;
List.Text := Json.ToString;
RootDir := IncludeTrailingPathDelimiter(ExtractFileDir(GetModuleName(HInstance)));
AccDir := IntToStr(AAccount) + PathDelim;
// каталог
ForceDirectories(ARootPath + AccDir);
List.SaveToFile(ARootPath + AccDir + CAreaFile, TEncoding.UTF8);
Result := True;
finally
List.Free;
Json.Free;
end;
except
Result := False;
end;
end;
function TLandMarkArea.SaveLandMarks(const ARootPath: string;
const AAccount: integer; const AGeoHashID: string; ALandMarkDict: TLandMarkDictionary): Boolean;
var
IdxFile, DatFile: TFileStream;
DatFileWriter: TStreamWriter;
IdxFileName, DatFileName, FileName: string;
Way: TWayLen;
HashVector: THashVector;
ZoneTrackDict: TZoneTrackDictionary;
Zone: UInt64;
LandMarkIdx: TLandMarkIdxLenFileRecord;
begin
FileName := Copy(AGeoHashID,3,12) + '_' + Copy(AGeoHashID,15,12);
IdxFileName := ARootPath + IntToStr(AAccount) + PathDelim + FileName + '.idx';
DatFileName := ARootPath + IntToStr(AAccount) + PathDelim + FileName + '.dat';
if FileExists(IdxFileName) then
DeleteFile(PChar(IdxFileName));
if FileExists(DatFileName) then
DeleteFile(PChar(DatFileName));
try
IdxFile := TFileStream.Create(IdxFileName, fmCreate + fmOpenReadWrite);
DatFile := TFileStream.Create(DatFileName, fmCreate + fmOpenReadWrite);
DatFileWriter := TStreamWriter.Create(DatFile);
try
IdxFile.Seek(0, soFromBeginning);
DatFile.Seek(0, soFromBeginning);
for HashVector in ALandMarkDict.Keys do
begin
ALandMarkDict.TryGetValue(HashVector,ZoneTrackDict);
for Zone in ZoneTrackDict.Keys do
begin
ZoneTrackDict.TryGetValue(Zone, Way);
if Way.Way <> 'error' then
begin
LandMarkIdx.i := DatFile.Position;
LandMarkIdx.k.v := HashVector;
LandMarkIdx.k.z := Zone;
LandMarkIdx.l := Way.Len;//Items[k].Distance;
DatFileWriter.WriteLine(Way.Way);
IdxFile.Write(LandMarkIdx, SizeOf(LandMarkIdx));
end;
end;
end;
Result := True;
finally
IdxFile.Free;
DatFileWriter.Free;
DatFile.Free;
end;
except
Result := False;
end;
end;
function TLandMarkArea.LM2GW(AWay: string): string;
var
Points: TGeoPosArray;
begin
TGeoHash.DecodeArrayWorld(AWay, Points);
Result := TGeoHash.EncodeArrayWorld(Points);
end;
class procedure TLandMarkArea.Stop;
begin
ToLog('TLandMarkArea Manual Stop');
end;
end.
|
program problem09;
uses crt;
(*
Problem: Special Pythagorean triplet
Problem 9
@Author: Chris M. Perez
@Date: 5/15/2017
*)
const
MAX: longint = 1000;
function pythagoreanTriplet(arg: longint): longint;
var
isPythagoreanTriplet: boolean = false;
product: longint = 1;
k: longint = 0;
i , j: longint;
begin
for i := 1 to MAX div 3 do begin
for j := i to MAX div 2 do begin
k := MAX - i - j;
if (i * i) + (j * j) = (k * k) then begin
isPythagoreanTriplet := true;
product := i * j * k;
break;
end;
end;
if isPythagoreanTriplet then begin
break;
end;
end;
pythagoreanTriplet := product;
end;
var
result: longint = 0;
begin
result := pythagoreanTriplet(MAX);
writeln(result);
readkey;
end.
|
unit TestingCommon;
interface
uses TestFramework;
var
TestCasesDir: string = ''; //all tests must keep subfolders for data
SpeedTests: TTestSuite; //register any performance tests here. Nil => do not register
function CommonDataDir: string; inline; //where stuff like dictionaries and resources is
procedure RegisterSpeedTest(Test: ITest);
type
//Usage: RegisterTest(TNamedTestSuite.Create(AClass))
TNamedTestSuite = class(TTestSuite)
public
constructor Create(const AName: string; AClass: TTestCaseClass);
end;
type
TStringArray = array of string;
function FileList(const APath, AMask: string): TStringArray;
implementation
uses SysUtils;
function CommonDataDir: string;
begin
Result := ExtractFilePath(ParamStr(0)); //for now
end;
procedure RegisterSpeedTest(Test: ITest);
begin
if SpeedTests <> nil then
SpeedTests.AddTest(Test);
end;
constructor TNamedTestSuite.Create(const AName: string; AClass: TTestCaseClass);
begin
inherited Create(AClass);
Self.FTestName := AName;
end;
function FileList(const APath, AMask: string): TStringArray;
var sr: TSearchRec;
res: integer;
begin
SetLength(Result, 0);
res := FindFirst(APath+'\'+AMask, faAnyFile and not faDirectory, sr);
while res = 0 do begin
SetLength(Result, Length(Result)+1);
Result[Length(Result)-1] := APath+'\'+sr.Name;
res := FindNext(sr);
end;
SysUtils.FindClose(sr);
end;
initialization
//To change this in time before tests start using it, set in the initialization section of a unit
//sufficiently high in the project's uses list.
TestCasesDir := ExtractFilePath(ParamStr(0))+'\Tests';
if not FindCmdLineSwitch('nospeed') then begin
SpeedTests := TTestSuite.Create('Speed Tests');
RegisterTest(SpeedTests);
end;
end.
|
{$I-,Q-,R-,S-}
{Problem 6: Bad Hair Day [Brian Dean, 2006]
Some of Farmer John's N cows (1 <= N <= 80,000) are having a bad
hair day! Since each cow is self-conscious about her messy hairstyle,
FJ wants to count the number of other cows that can see the top of
other cows' heads.
Each cow i has a specified height h[i] (1 <= h[i] <= 1,000,000,000)
and is standing in a line of cows all facing east (to the right in
our diagrams). Therefore, cow i can see the tops of the heads of
cows in front of her (namely cows i+1, i+2, and so on), for as long
as these cows are strictly shorter than cow i.
Consider this example:
=
= =
= - = Cows facing right -->
= = =
= - = = =
= = = = = =
1 2 3 4 5 6
Cow#1 can see the hairstyle of cows #2, 3, 4
Cow#2 can see no cow's hairstyle
Cow#3 can see the hairstyle of cow #4
Cow#4 can see no cow's hairstyle
Cow#5 can see the hairstyle of cow 6
Cow#6 can see no cows at all!
Let c[i] denote the number of cows whose hairstyle is visible from
cow i; please compute the sum of c[1] through c[N]. For this example,
the desired is answer 3 + 0 + 1 + 0 + 1 + 0 = 5.
TIME LIMIT: 0.5 seconds
PROBLEM NAME: badhair
INPUT FORMAT:
* Line 1: The number of cows, N.
* Lines 2..N+1: Line i+1 contains a single integer that is the height
of cow i.
SAMPLE INPUT (file badhair.in):
6
10
3
7
4
12
2
INPUT DETAILS:
Six cows stand in a line; heights are 10, 3, 7, 4, 12, 2.
OUTPUT FORMAT:
* Line 1: A single integer that is the sum of c[1] through c[N].
SAMPLE OUTPUT (file badhair.out):
5
}
const
mx = 80001;
var
fe,fs : text;
sol : int64;
n : longint;
tab,last : array[1..mx] of longint;
cont : array[1..mx] of int64;
procedure open;
var
i : longint;
begin
assign(fe,'badhair.in'); reset(fe);
assign(fs,'badhair.out'); rewrite(fs);
readln(fe,n);
for i:=1 to n do
readln(fe,tab[i]);
close(fe);
end;
procedure work;
var
i,j : longint;
begin
sol:=0; tab[n+1]:=maxlongint; last[n]:=n+1;
for i:=n-1 downto 1 do
begin
j:=i+1;
cont[i]:=0;
last[i]:=j;
while (tab[j] < tab[i]) do
begin
cont[i]:=cont[i] + cont[j] + 1;
last[i]:=last[j];
j:=last[j];
end;
end;
for i:=1 to n do sol:=sol + cont[i];
end;
procedure closer;
begin
writeln(fs,sol);
close(fs);
end;
begin
open;
work;
closer;
end. |
{################################################}
{# Program Fahr #}
{# | | _ |V| _|\| _ __ _ _ #}
{# |__|_||<(/_ | |(_| |(/_|||(/_(/_ #}
{# 2015 #}
{################################################}
{# převod jednotek z stupnu celsia na #}
{# fahrenheity #}
{################################################}
Program fahr;
var
i : integer;
fahrenheit, celsius : real;
dolni, kroky, krok : integer;
begin
writeln('zadejte dolni hranici:');
readln(dolni);
writeln('zadejte pocet kroku:');
readln(kroky);
krok := 20;
celsius := dolni;
for i:= 1 to kroky do
begin
fahrenheit := (9.0 / 5.0) * celsius + 32.0;
writeln(celsius:6:2, ' ~ ', fahrenheit:6:2);
celsius := celsius + krok;
end;
readln;
end. |
{------------------------------------------------------------------------------
DzNoteEditor property editor
Developed by Rodrigo Depine Dalpiaz (digao dalpiaz)
Property Editor to TStrings class integrated in Delphi IDE
https://github.com/digao-dalpiaz/DzNoteEditor
Please, read the documentation at GitHub link.
------------------------------------------------------------------------------}
unit UFrmNoteEditor;
interface
uses Vcl.Forms, System.Classes, System.Actions, Vcl.ActnList,
SynEditMiscClasses, SynEditSearch, Vcl.Menus, Vcl.ImgList,
Vcl.Controls, Vcl.ComCtrls, Vcl.ToolWin, SynEdit, Vcl.StdCtrls, Vcl.Buttons,
Vcl.ExtCtrls,
{$IF CompilerVersion >= 29}System.ImageList, {$ENDIF}
//
SynEditHighlighter, SynEditTypes,
Winapi.Windows, Winapi.Messages,
System.Win.Registry,
DesignIntf;
type
TFrmNoteEditor = class(TForm)
BoxButtons: TPanel;
BtnCancel: TBitBtn;
BtnOK: TBitBtn;
BtnSave: TBitBtn;
IL: TImageList;
MenuSyn: TPopupMenu;
MenuConfig: TPopupMenu;
ItemStyleCodeEditor: TMenuItem;
Search: TSynEditSearch;
N1: TMenuItem;
ItemConfig: TMenuItem;
ItemStyleNormal: TMenuItem;
ItemColors: TMenuItem;
ItemWordWrap: TMenuItem;
N2: TMenuItem;
ActionList: TActionList;
Action_FindNext: TAction;
Action_Find: TAction;
Box: TPanel;
LbTitle: TLabel;
M: TSynEdit;
StatusBar: TStatusBar;
IL_Disab: TImageList;
Panel1: TPanel;
ToolBar: TToolBar;
BtnSyn: TToolButton;
BtnPower: TToolButton;
ToolButton15: TToolButton;
BtnCut: TToolButton;
BtnCopy: TToolButton;
BtnPaste: TToolButton;
ToolButton16: TToolButton;
BtnUndo: TToolButton;
BtnRedo: TToolButton;
ToolButton18: TToolButton;
BtnSelectAll: TToolButton;
BtnClear: TToolButton;
BtnCopyAll: TToolButton;
ToolButton19: TToolButton;
BtnFind: TToolButton;
BtnFindNext: TToolButton;
ToolButton20: TToolButton;
BtnImport: TToolButton;
BtnExport: TToolButton;
ToolButton21: TToolButton;
BtnConfig: TToolButton;
ItemSpecialChars: TMenuItem;
Action_Save: TAction;
Action_OK: TAction;
BtnHelp: TToolButton;
procedure MStatusChange(Sender: TObject; Changes: TSynStatusChanges);
procedure BtnSaveClick(Sender: TObject);
procedure BtnOKClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure BtnCutClick(Sender: TObject);
procedure BtnCopyClick(Sender: TObject);
procedure BtnPasteClick(Sender: TObject);
procedure BtnClearClick(Sender: TObject);
procedure BtnUndoClick(Sender: TObject);
procedure BtnRedoClick(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure BtnPowerClick(Sender: TObject);
procedure ItemStyleCodeEditorClick(Sender: TObject);
procedure BtnFindClick(Sender: TObject);
procedure ItemConfigClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure BtnImportClick(Sender: TObject);
procedure BtnSelectAllClick(Sender: TObject);
procedure BtnExportClick(Sender: TObject);
procedure BtnFindNextClick(Sender: TObject);
procedure ItemWordWrapClick(Sender: TObject);
procedure ItemColorsClick(Sender: TObject);
procedure BtnCopyAllClick(Sender: TObject);
procedure ItemSpecialCharsClick(Sender: TObject);
procedure Action_OKExecute(Sender: TObject);
procedure BtnHelpClick(Sender: TObject);
private
type
TMenuItemSyn = class(TMenuItem)
public
SynClass: TSynCustomHighlighterClass;
LangID, LangDesc, PathReg: string;
end;
var LastSynMenuItem: TMenuItemSyn;
Search_Opt: TSynSearchOptions;
Search_Find, Search_Replace: string;
Search_Em: Integer;
NextClip: HWND;
procedure ClipChange(var Msg: TWMChangeCBChain); message WM_CHANGECBCHAIN;
procedure ClipDraw(var Msg: TWMDrawClipboard); message WM_DRAWCLIPBOARD;
procedure CreateSyns(const SavedName: string);
procedure OnMenuItemSynClick(Sender: TObject);
public
PStr: TStrings;
Design: IDesigner;
end;
implementation
{$R *.dfm}
uses
Vcl.Graphics, System.SysUtils, System.StrUtils,
Vcl.ExtDlgs, Vcl.Clipbrd, Vcl.Dialogs, Winapi.ShellAPI,
UFrmNoteEditorFind, UFrmNoteEditorConfig, UFrmNoteEditorColors,
System.Generics.Defaults, System.Generics.Collections;
const REG_PATH = 'Digao\NoteEditor';
function RegReadString(Reg: TRegistry; const aName, aDefault: string): string;
begin
if Reg.ValueExists(aName) then
Result := Reg.ReadString(aName)
else
Result := aDefault;
end;
function RegReadInteger(Reg: TRegistry; const aName: string;
const aDefault: Integer): Integer;
begin
if Reg.ValueExists(aName) then
Result := Reg.ReadInteger(aName)
else
Result := aDefault;
end;
function RegReadBoolean(Reg: TRegistry; const aName: string;
const aDefault: Boolean): Boolean;
begin
if Reg.ValueExists(aName) then
Result := Reg.ReadBool(aName)
else
Result := aDefault;
end;
//
procedure SaveFormPos(Reg: TRegistry; F: TForm);
var WP: TWindowPlacement;
begin
WP.Length := SizeOf( TWindowPlacement );
GetWindowPlacement( F.Handle, @WP );
if Reg.OpenKey('Window', True) then //should return always true !
begin
Reg.WriteInteger('X', WP.rcNormalPosition.Left);
Reg.WriteInteger('Y', WP.rcNormalPosition.Top);
Reg.WriteInteger('W', WP.rcNormalPosition.Width);
Reg.WriteInteger('H', WP.rcNormalPosition.Height);
Reg.WriteBool('Max', (F.WindowState=wsMaximized) );
end;
end;
procedure LoadFormPos(Reg: TRegistry; F: TForm);
begin
if Reg.OpenKeyReadOnly('Window') then //only if was saved before
begin
F.Left := Reg.ReadInteger('X');
F.Top := Reg.ReadInteger('Y');
F.Width := Reg.ReadInteger('W');
F.Height := Reg.ReadInteger('H');
if Reg.ReadBool('Max') then
F.WindowState := wsMaximized;
F.Position := poDesigned;
end;
end;
//
type TMyHC = class
ID, Caption: string;
&Class: TSynCustomHighlighterClass;
end;
procedure TFrmNoteEditor.CreateSyns(const SavedName: string);
var C: TSynCustomHighlighterClass;
MI: TMenuItemSyn;
L: TSynHighlighterList;
I, Count: Integer;
MyLst: TList<TMyHC>;
HC: TMyHC;
begin
L := GetPlaceableHighlighters;
MyLst := TList<TMyHC>.Create;
try
for I := 0 to L.Count-1 do
begin
C := L[I];
HC := TMyHC.Create;
MyLst.Add(HC);
HC.&Class := C;
HC.ID := C.GetLanguageName;
HC.Caption := C.GetFriendlyLanguageName;
end;
MyLst.Sort(TComparer<TMyHC>.Construct(
function(const Item1, Item2: TMyHC): Integer
begin
Result := CompareText(Item1.Caption, Item2.Caption);
end)
);
Count := 0;
for HC in MyLst do
begin
MI := TMenuItemSyn.Create(Self);
MI.SynClass := HC.&Class;
MI.LangID := HC.ID;
MI.LangDesc := HC.Caption;
MI.PathReg := REG_PATH+'\Languages\'+MI.LangID;
MenuSyn.Items.Add(MI);
MI.Caption := MI.LangDesc;
MI.OnClick := OnMenuItemSynClick;
MI.RadioItem := True; //set bullet graphic and auto-uncheck when set any other on same group
if MI.LangID = SavedName then LastSynMenuItem := MI;
if Count>20 then
begin
MI.Break := mbBarBreak;
Count := 0;
end;
Inc(Count);
end;
finally
MyLst.Free;
end;
end;
procedure TFrmNoteEditor.OnMenuItemSynClick(Sender: TObject);
var MI: TMenuItemSyn;
begin
if Assigned(M.Highlighter) then M.Highlighter.Free; //previous syn
if Sender=nil then
begin
M.Highlighter := nil;
StatusBar.Panels[4].Text := 'Plain Text';
end else
begin
MI := TMenuItemSyn(Sender);
MI.Checked := True;
M.Highlighter := MI.SynClass.Create(Self);
M.Highlighter.LoadFromRegistry(HKEY_CURRENT_USER, MI.PathReg);
StatusBar.Panels[4].Text := MI.LangDesc;
LastSynMenuItem := MI;
end;
end;
procedure TFrmNoteEditor.BtnPowerClick(Sender: TObject);
begin
if BtnPower.Down then
begin
BtnSyn.Enabled := True;
//BtnSyn.ImageIndex := 0;
BtnPower.ImageIndex := 3;
OnMenuItemSynClick(LastSynMenuItem);
end else
begin
BtnSyn.Enabled := False;
//BtnSyn.ImageIndex := 1;
BtnPower.ImageIndex := 2;
OnMenuItemSynClick(nil);
end;
end;
//
procedure TFrmNoteEditor.ClipChange(var Msg: TWMChangeCBChain);
begin
inherited;
Msg.Result := 0;
if Msg.Remove = NextClip then
NextClip := Msg.Next else
SendMessage(NextClip, WM_CHANGECBCHAIN, Msg.Remove, Msg.Next);
end;
procedure TFrmNoteEditor.ClipDraw(var Msg: TWMDrawClipboard);
begin
inherited;
//
BtnPaste.Enabled := M.CanPaste;
//
SendMessage(NextClip, WM_DRAWCLIPBOARD, 0, 0);
end;
//
procedure TFrmNoteEditor.FormCreate(Sender: TObject);
var Reg: TRegistry;
begin
Box.Anchors := [akLeft,akRight,akTop,akBottom];
BoxButtons.Anchors := [akBottom];
//
NextClip := SetClipboardViewer(Handle);
//
M.WantTabs := True; //allow insert tab in the text instead of jump focus control
M.Gutter.ShowLineNumbers := True; //show line numbers at gutter
M.Gutter.ShowModification := True; //show line modification mark at gutter
M.Options := M.Options + [eoAltSetsColumnMode]; //allow alt to column select mode
Reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CURRENT_USER;
Reg.OpenKey(REG_PATH, True);
CreateSyns( RegReadString(Reg, 'Language', 'SQL') );
M.Color := RegReadInteger(Reg, 'BgColor', clWindow);
M.Font.Color := RegReadInteger(Reg, 'FontColor', clWindowText);
M.Font.Name := RegReadString(Reg, 'Font', 'Courier New');
M.Font.Size := RegReadInteger(Reg, 'Size', 10);
M.Font.Style := TFontStyles(Byte(RegReadInteger(Reg, 'Style', 0)));
if RegReadBoolean(Reg, 'Code', True) then
ItemStyleCodeEditor.Click
else
ItemStyleNormal.Click;
ItemWordWrap.Checked := RegReadBoolean(Reg, 'WordWrap', False);
ItemWordWrapClick(nil);
ItemSpecialChars.Checked := RegReadBoolean(Reg, 'SpecialChars', False);
ItemSpecialCharsClick(nil);
BtnPower.Down := RegReadBoolean(Reg, 'SynEnabled', False);
BtnPowerClick(nil);
LoadFormPos(Reg, Self); //this should be the last thing because changes the registry path
finally
Reg.Free;
end;
end;
procedure TFrmNoteEditor.FormDestroy(Sender: TObject);
var Reg: TRegistry;
begin
if NextClip <> 0 then
ChangeClipboardChain(Handle, NextClip);
//
Reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CURRENT_USER;
Reg.OpenKey(REG_PATH, True);
if Assigned(LastSynMenuItem) then
Reg.WriteString('Language', LastSynMenuItem.LangID);
Reg.WriteBool('SynEnabled', BtnPower.Down);
Reg.WriteInteger('BgColor', M.Color);
Reg.WriteInteger('FontColor', M.Font.Color);
Reg.WriteString('Font', M.Font.Name);
Reg.WriteInteger('Size', M.Font.Size);
Reg.WriteInteger('Style', Byte(M.Font.Style));
Reg.WriteBool('Code', ItemStyleCodeEditor.Checked);
Reg.WriteBool('WordWrap', ItemWordWrap.Checked);
Reg.WriteBool('SpecialChars', ItemSpecialChars.Checked);
SaveFormPos(Reg, Self); //this should be the last thing because changes the registry path
finally
Reg.Free;
end;
end;
procedure TFrmNoteEditor.FormShow(Sender: TObject);
begin
M.Lines.Assign(PStr);
MStatusChange(nil, [scCaretX, scCaretY, scSelection, scInsertMode]);
end;
procedure TFrmNoteEditor.MStatusChange(Sender: TObject;
Changes: TSynStatusChanges);
var aCount: string;
begin
if (scCaretX in Changes) or
(scCaretY in Changes) then
begin
StatusBar.Panels[0].Text := Format('%u: %u', [M.CaretY, M.CaretX]);
end;
if (scSelection in Changes) then
begin
if (M.Text = '') then aCount := 'Empty' else
if (M.Lines.Count = 1) then aCount := '1 line' else
aCount := IntToStr(M.Lines.Count) + ' lines';
StatusBar.Panels[1].Text := aCount;
BtnCut.Enabled := M.SelAvail;
BtnCopy.Enabled := M.SelAvail;
BtnSelectAll.Enabled := (M.Text<>'');
BtnClear.Enabled := BtnSelectAll.Enabled;
BtnCopyAll.Enabled := BtnSelectAll.Enabled;
BtnExport.Enabled := BtnSelectAll.Enabled;
BtnFind.Enabled := BtnSelectAll.Enabled;
BtnFindNext.Enabled := BtnSelectAll.Enabled;
BtnUndo.Enabled := M.CanUndo;
BtnRedo.Enabled := M.CanRedo;
end;
if (scModified in Changes) then
begin
StatusBar.Panels[2].Text := IfThen(M.Modified, 'Modified');
BtnSave.Enabled := M.Modified;
end;
if (scInsertMode in Changes) then
begin
StatusBar.Panels[3].Text := IfThen(M.InsertMode, 'Inserting', '* Overwriting *');
end;
end;
procedure TFrmNoteEditor.BtnSaveClick(Sender: TObject);
begin
if not BtnSave.Enabled then Exit;
if (M.Text = '') then
PStr.Clear
else
PStr.Assign(M.Lines);
M.Modified := False;
Design.Modified;
end;
procedure TFrmNoteEditor.BtnOKClick(Sender: TObject);
begin
BtnSaveClick(nil);
end;
procedure TFrmNoteEditor.BtnCutClick(Sender: TObject);
begin
M.CutToClipboard;
end;
procedure TFrmNoteEditor.BtnCopyClick(Sender: TObject);
begin
M.CopyToClipboard;
end;
procedure TFrmNoteEditor.BtnPasteClick(Sender: TObject);
begin
M.PasteFromClipboard;
end;
procedure TFrmNoteEditor.BtnSelectAllClick(Sender: TObject);
begin
M.SelectAll;
end;
procedure TFrmNoteEditor.BtnClearClick(Sender: TObject);
begin
M.SelectAll;
M.ClearSelection;
end;
procedure TFrmNoteEditor.BtnCopyAllClick(Sender: TObject);
begin
Clipboard.AsText := M.Text;
end;
procedure TFrmNoteEditor.BtnUndoClick(Sender: TObject);
begin
M.Undo;
end;
procedure TFrmNoteEditor.BtnRedoClick(Sender: TObject);
begin
M.Redo;
end;
procedure TFrmNoteEditor.BtnFindClick(Sender: TObject);
var B: TFrmNoteEditorFind;
begin
if not BtnFind.Enabled then Exit;
B := TFrmNoteEditorFind.Create(Application);
try
B.EdFind.Text := Search_Find;
B.EdReplace.Text := Search_Replace;
B.CkReplace.Checked := ssoReplace in Search_Opt;
B.CkSensitive.Checked := ssoMatchCase in Search_Opt;
B.CkWholeWord.Checked := ssoWholeWord in Search_Opt;
B.CkReplaceAll.Checked := ssoReplaceAll in Search_Opt;
B.Em.ItemIndex := Search_Em;
if M.SelAvail then //has text selected
begin
if M.SelTabBlock then //multiple lines selected
B.Em.ItemIndex := 1 //set selection find option by default
else
B.EdFind.Text := M.SelText; //fill search text with selected text
end;
if B.ShowModal = mrOk then
begin
Search_Opt := [];
if B.CkSensitive.Checked then Include(Search_Opt, ssoMatchCase);
if B.CkWholeWord.Checked then Include(Search_Opt, ssoWholeWord);
if B.CkReplace.Checked then Include(Search_Opt, ssoReplace);
if B.CkReplaceAll.Checked then Include(Search_Opt, ssoReplaceAll);
case B.Em.ItemIndex of
0: Include(Search_Opt, ssoEntireScope);
1: Include(Search_Opt, ssoSelectedOnly);
2: Include(Search_Opt, ssoBackwards);
3: {abaixo};
end;
Search_Find := B.EdFind.Text;
Search_Replace := B.EdReplace.Text;
Search_Em := B.Em.ItemIndex;
if M.SearchReplace(Search_Find, Search_Replace, Search_Opt) = 0 then
ShowMessage('Text not found')
else
if (ssoReplaceAll in Search_Opt) then
ShowMessage('Replacements: ' + IntToStr(Search.Count));
end;
finally
B.Free;
end;
end;
procedure TFrmNoteEditor.BtnFindNextClick(Sender: TObject);
begin
if not BtnFindNext.Enabled then Exit;
if (Search_Find<>'') and not (ssoReplace in Search_Opt) then
begin
Exclude(Search_Opt, ssoEntireScope);
Exclude(Search_Opt, ssoSelectedOnly);
if M.SearchReplace(Search_Find, '', Search_Opt) = 0 then
ShowMessage('Text not found');
end
else BtnFindClick(nil);
end;
procedure TFrmNoteEditor.ItemStyleCodeEditorClick(Sender: TObject);
var X: TSynEditorOptions;
begin
TMenuItem(Sender).Checked := True;
X := [eoScrollPastEol, //allow cursor oversizes text end of line
eoAutoIndent,
eoTabsToSpaces, //insert spaces on type tab
eoTrimTrailingSpaces, //clear white spaces at the end of the line
eoEnhanceHomeKey, //home key first stops at start of the text and then at the start of the line
eoEnhanceEndKey, //end key first stops at end of the text and then at the end of the line
eoTabIndent];
if ItemStyleCodeEditor.Checked then
M.Options := M.Options + X
else
M.Options := M.Options - X;
M.Gutter.ZeroStart := ItemStyleNormal.Checked;
end;
procedure TFrmNoteEditor.ItemSpecialCharsClick(Sender: TObject);
begin
if ItemSpecialChars.Checked then
M.Options := M.Options + [eoShowSpecialChars]
else
M.Options := M.Options - [eoShowSpecialChars];
end;
procedure TFrmNoteEditor.ItemWordWrapClick(Sender: TObject);
begin
M.WordWrap := ItemWordWrap.Checked;
end;
procedure TFrmNoteEditor.ItemConfigClick(Sender: TObject);
var F: TFrmNoteEditorConfig;
begin
F := TFrmNoteEditorConfig.Create(Application);
try
F.Lb.Font.Assign(M.Font);
F.EdBgColor.Selected := M.Color;
if F.ShowModal = mrOk then
begin
M.Font.Assign(F.Lb.Font);
M.Color := F.EdBgColor.Selected;
end;
finally
F.Free;
end;
end;
procedure TFrmNoteEditor.ItemColorsClick(Sender: TObject);
var MI: TMenuItemSyn;
F: TFrmNoteEditorColors;
begin
if not Assigned(M.Highlighter) then
begin
ShowMessage('Please, first set an active language.');
Exit;
end;
MI := LastSynMenuItem;
F := TFrmNoteEditorColors.Create(Application);
try
F.LbLang.Caption := MI.LangDesc;
F.SynEdit := M;
if F.Run then
M.Highlighter.SaveToRegistry(HKEY_CURRENT_USER, MI.PathReg);
finally
F.Free;
end;
end;
procedure TFrmNoteEditor.BtnImportClick(Sender: TObject);
var D: TOpenTextFileDialog;
S: TStringList;
begin
D := TOpenTextFileDialog.Create(nil);
try
D.Title := 'Import from File';
D.Filter := 'Text File|*.txt|All Files|*';
if D.Execute then
begin
S := TStringList.Create;
try
S.LoadFromFile(D.FileName, D.Encodings.Objects[D.EncodingIndex] as TEncoding);
M.SelText := S.Text;
finally
S.Free;
end;
end;
finally
D.Free;
end;
end;
procedure TFrmNoteEditor.BtnExportClick(Sender: TObject);
var D: TSaveTextFileDialog;
begin
D := TSaveTextFileDialog.Create(nil);
try
D.Title := 'Exportar to File';
D.DefaultExt := 'txt';
D.Filter := 'Text File|*.txt|All Files|*';
if D.Execute then
M.Lines.SaveToFile(D.FileName, D.Encodings.Objects[D.EncodingIndex] as TEncoding);
finally
D.Free;
end;
end;
procedure TFrmNoteEditor.Action_OKExecute(Sender: TObject);
begin
BtnOK.Click;
end;
procedure TFrmNoteEditor.BtnHelpClick(Sender: TObject);
begin
ShellExecute(0, '', 'https://github.com/digao-dalpiaz/DzNoteEditor', '', '', SW_SHOWNORMAL);
end;
end.
|
{$modeswitch nestedprocvars}
//=============================================================================
// sgPhysics.pas
//=============================================================================
//
// Responsible for performing collisions and vector maths.
//
//=============================================================================
/// The physics contains code to check and perform collisions between bitmaps and shapes
/// in SwinGame. This code will help you determine if two sprites have hit each other,
/// or allow you to bounce one sprite off another or off a stationary shape.
///
/// The functions that contain the text "collision" are used to determine if two
/// ``things`` have collided, for example `BitmapPointCollision` is used to determine
/// if a bitmap (with a specified location) has collided with a given point.
///
/// The procedures that contain the text "collide" are used to perform a "bounce"
/// style collision, where a sprite is bounced off some other ``thing``. For example
/// `CollideCircleLine` is used to bounce a sprite (which should be treated like a circle)
/// off a given line.
///
/// @module Physics
/// @static
unit sgPhysics;
//=============================================================================
interface
uses sgTypes;
//=============================================================================
//---------------------------------------------------------------------------
// Sprite <-> Sprite Collision Detection
//---------------------------------------------------------------------------
/// Returns ``true`` if the specifed sprites (``s1`` and ``s2``) have
/// collided. Will use simple bounding box tests first, and low-level pixel
/// tests if needed.
///
/// @lib
/// @sn sprite:%s collisionWithSprite:%s
///
/// @class Sprite
/// @method CollisionWithSprite
function SpriteCollision(s1, s2: Sprite): Boolean;
//---------------------------------------------------------------------------
// Sprite <-> Rectangle Collision Detection
//---------------------------------------------------------------------------
/// Determined if a sprite has collided with a given rectangle. The rectangles
/// coordinates are expressed in "world" coordinates.
///
/// @lib
/// @sn sprite:%s collisionWithRectX:%s y:%s width:%s height:%s
///
/// @class Sprite
/// @method RectCollision
/// @csn collisionWithRectX:%s y:%s width:%s height:%s
function SpriteRectCollision(s: Sprite; x, y, width, height: Single): Boolean; overload;
/// Returns true if the sprite has collided with a rectangle.
///
/// @lib SpriteRectangleCollision
/// @sn sprite:%s collisionWithRect:%s
///
/// @class Sprite
/// @overload RectCollision RectangleCollision
/// @csn collisionWithRect:%s
function SpriteRectCollision(s: Sprite; const r: Rectangle): Boolean; overload;
/// Returns true if the sprite exists at a certain point.
///
/// @lib
/// @sn sprite:%s atPoint:%s
///
/// @class Sprite
/// @method AtPoint
/// @csn atPoint:%s
function SpriteAtPoint(s: Sprite; const pt: Point2D): Boolean; overload;
//---------------------------------------------------------------------------
// Sprite <-> Bitmap Collision Detection
//---------------------------------------------------------------------------
/// Determines if the `Sprite` ``s`` has collided with the bitmap ``bmp`` using
/// pixel level testing if required.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
///
/// @lib
/// @sn sprite:%s collisionWithBitmap:%s x:%s y:%s
///
/// @uname SpriteBitmapCollision
/// @class Sprite
/// @method BitmapCollision
/// @csn collisionWithBitmap:%s x:%s y:%s
function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; x, y: Single): Boolean; overload;
/// Determines if the `Sprite` ``s`` has collided with the bitmap ``bmp`` using
/// pixel level testing if required.
/// The ``pt`` (`Point2D`) value specifies the world location of the bitmap.
///
/// @lib SpriteBitmapAtPointCollision
/// @sn sprite:%s collisionWithBitmap:%s at:%s
///
/// @class Sprite
/// @overload BitmapCollision BitmapAtPointCollision
/// @csn collisionWithBitmap:%s at:%s
function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; const pt: Point2D): Boolean; overload;
//---------------------------------------------------------------------------
// Bitmap <-> Rectangle Collision Tests
//---------------------------------------------------------------------------
/// Returns True if the bitmap ``bmp`` has collided with the rectangle
/// specified using pixel level testing if required.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The rectangles world position (``rectX`` and ``rectY``) and size
/// (``rectWidth`` and ``rectHeight``) need to be provided.
///
/// @lib BitmapRectCollision
/// @sn bitmap:%s collisionAtX:%s y:%s withRectX:%s y:%s width:%s height:%s
///
/// @class Bitmap
/// @method RectCollision
/// @csn collisionAtX:%s y:%s withRectX:%s y:%s width:%s height:%s
function BitmapRectCollision(bmp: Bitmap; x, y, rectX, rectY, rectWidth, rectHeight: Single): Boolean; overload;
/// Returns True if the bitmap ``bmp`` has collided with the rectangle
/// specified using pixel level testing if required.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The rectangle ``rect`` needs to be provided in world coordinates.
///
/// @lib BitmapRectangleCollision
/// @sn bitmap:%s collisionAtX:%s y:%s withRect:%s
///
/// @class Bitmap
/// @overload RectCollision RectangleCollision
/// @csn collisionAtX:%s y:%s withRect:%s
function BitmapRectCollision(bmp: Bitmap; x, y: Single; const rect: Rectangle): Boolean; overload;
/// Returns True if the indicated part of the bitmap has collided with the specified
/// rectangle.
///
/// @lib BitmapPartRectCollision
/// @sn bitmap:%s collisionAtX:%s y:%s part:%s withRect:%s
///
/// @class Bitmap
/// @overload RectCollision RectPartCollision
/// @csn collisionAtX:%s y:%s part:%s withRect:%s
function BitmapRectCollision(bmp: Bitmap; x, y: Single; const part, rect: Rectangle): Boolean; overload;
/// Returns True if the indicated part of the bitmap has collided with the specified
/// rectangle.
///
/// @lib BitmapPartAtPtRectCollision
/// @sn bitmap:%s atPt:%s part:%s collisionWithRect:%s
///
/// @class Bitmap
/// @overload RectCollision RectPartCollisionAtPoint
/// @csn atPt:%s part:%s collisionWithRect:%s
function BitmapRectCollision(bmp: Bitmap; const pt:Point2D; const part, rect: Rectangle): Boolean; overload;
//---------------------------------------------------------------------------
// Bitmap <-> Point
//---------------------------------------------------------------------------
/// Returns True if a point (``ptX``,``ptY``) is located within the bitmap
/// ``bmp`` when it is drawn at ``x``,``y``, using pixel level collisions.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The ``ptX`` and ``ptY`` needs to be provided in world coordinates.
///
/// @lib BitmapPointCollision
/// @sn bitmap:%s atX:%s y:%s collisionWithPtX:%s y:%s
///
/// @class Bitmap
/// @method PointCollision
/// @csn atX:%s y:%s collisionWithPtX:%s y:%s
function BitmapPointCollision(bmp: Bitmap; x, y, ptX, ptY: Single): Boolean; overload;
/// Returns True if a point (``pt``) is located within the bitmap
/// ``bmp`` when it is drawn at ``x``,``y``, using pixel level collisions.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The point ``pt`` needs to be provided in world coordinates.
///
/// @lib BitmapPointPtCollision
/// @sn bitmap:%s atX:%s y:%s collisionWithPt:%s
///
/// @class Bitmap
/// @overload PointCollision PointPtCollision
/// @csn atX:%s y:%s collisionWithPt:%s
function BitmapPointCollision(bmp: Bitmap; x, y: Single; const pt: Point2D): Boolean; overload;
/// Returns True if a point (``ptX``,``ptY``) is located within the ``part`` (rectangle) of the bitmap
/// ``bmp`` when it is drawn at ``x``,``y``, using pixel level collisions. For bounding box collisions
/// use the rectangle collision functions.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The ``ptX`` and ``ptY`` needs to be provided in world coordinates.
///
/// @lib
/// @sn bitmap:%s atX:%s y:%s part:%s collisionWithPtX:%s y:%s
///
/// @class Bitmap
/// @overload PointCollision PointPartCollision
/// @csn atX:%s y:%s part:%s collisionWithPtX:%s y:%s
function BitmapPartPointCollision(bmp: Bitmap; x, y: Single; const part: Rectangle; ptX, ptY: Single): Boolean; overload;
/// Returns True if a point (``pt``) is located within the ``part`` (rectangle) of the bitmap
/// ``bmp`` when it is drawn at ``x``,``y``, using pixel level collisions. For bounding box collisions
/// use the rectangle collision functions.
/// The ``x`` and ``y`` values specify the world location of the bitmap.
/// The point ``pt`` needs to be provided in world coordinates.
///
/// @lib BitmapPartPointXYCollision
/// @sn bitmap:%s atX:%s y:%s part:%s collisionWithPt:%s
///
/// @class Bitmap
/// @overload PointCollision PointPartCollisionWithPt
/// @csn atX:%s y:%s part:%s collisionWithPt:%s
function BitmapPartPointCollision(bmp: Bitmap; x, y: Single; const part: Rectangle; const pt: Point2D): Boolean; overload;
//---------------------------------------------------------------------------
// Bitmap <-> Bitmap Collision Tests
//---------------------------------------------------------------------------
/// Returns True if two bitmaps have collided using per pixel testing if required.
/// The ``x`` and ``y`` parameters specify the world location of the bitmaps (``bmp1`` and ``bmp2``).
///
/// @lib BitmapCollision
/// @sn bitmap:%s atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s
///
/// @class Bitmap
/// @method BitmapCollision
/// @csn atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s
function BitmapCollision(bmp1: Bitmap; x1, y1: Single; bmp2: Bitmap; x2, y2: Single): Boolean; overload;
/// Returns True if two bitmaps have collided using per pixel testing if required.
/// The ``pt1`` and ``pt2`` (`Point2D`) parameters specify the world location of the bitmaps (``bmp1`` and ``bmp2``).
///
/// @lib BitmapAtPointsCollision
/// @sn bitmap:%s at:%s collisionWithBitmap:%s atPt:%s
///
/// @class Bitmap
/// @overload BitmapCollision BitmapAtPointCollision
/// @csn at:%s collisionWithBitmap:%s atPt:%s
function BitmapCollision(bmp1: Bitmap; const pt1: Point2D; bmp2: Bitmap; const pt2: Point2D): Boolean; overload;
/// Returns True if the specified parts (``part1`` and ``part2`` rectangles) of the two
/// bitmaps (``bmp1`` and ``bmpt2``) have collided, using pixel level collision if required.
/// The ``pt1`` and ``pt2`` (`Point2D`) parameters specify the world location of the bitmaps (``bmp1`` and ``bmp2``).
///
/// @lib BitmapsPartsCollision
/// @sn bitmap:%s at:%s part:%s collisionWith:%s at:%s part:%s
///
/// @class Bitmap
/// @overload BitmapCollision BitmapPartCollision
/// @csn at:%s part:%s collisionWith:%s at:%s part:%s
function BitmapCollision(bmp1: Bitmap; const pt1: Point2D; const part1: Rectangle; bmp2: Bitmap; const pt2: Point2D; const part2: Rectangle): Boolean; overload;
//---------------------------------------------------------------------------
// Cell based Collision Tests
//---------------------------------------------------------------------------
/// Returns true if the cells within the two bitmaps have collided at their specified x,y locations.
///
/// @lib
/// @sn bitmap:%s cell:%s atX:%s y:%s collisionWithBitmap:%s cell:%s atX:%s y:%s
///
/// @class Bitmap
/// @overload CellCollision CellCollisionXY
/// @csn cell:%s atX:%s y:%s collisionWithBitmap:%s cell:%s atX:%s y:%s
function CellCollision( bmp1: Bitmap; cell1: Longint; x1, y1: Single;
bmp2: Bitmap; cell2: Longint; x2, y2: Single): Boolean; overload;
/// Returns true if the cells within the two bitmaps have collided at the given points.
///
/// @lib CellCollisionAtPt
/// @sn bitmap:%s cell:%s at:%s collisionWithBitmap:%s cell:%s at:%s
///
/// @class Bitmap
/// @method CellCollision
/// @csn cell:%s at:%s collisionWithBitmap:%s cell:%s at:%s
function CellCollision( bmp1: Bitmap; cell1: Longint; const pt1: Point2D;
bmp2: Bitmap; cell2: Longint; const pt2: Point2D): Boolean; overload;
/// Returns true if the cell in the specified bitmap has collided with a bitmap.
///
/// @lib
/// @sn bitmap:%s cell:%s atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s
///
/// @class Bitmap
/// @method CellBitmapCollision
/// @csn cell:%s atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; x1, y1: Single;
bmp2: Bitmap; x2, y2: Single): Boolean; overload;
/// Returns true if the cell in the specified bitmap has collided with a bitmap.
///
/// @lib CellBitmapCollisionAtPt
/// @sn bitmap:%s cell:%s at:%s collisionWithBitmap:%s at:%s
///
/// @class Bitmap
/// @overload CellBitmapCollision CellBitmapCollisionAtPt
/// @csn cell:%s at:%s collisionWithBitmap:%s at:%s
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; const pt1: Point2D;
bmp2: Bitmap; const pt2: Point2D): Boolean; overload;
/// Returns true if the cell in the specified bitmap has collided with a part of a bitmap.
///
/// @lib CellBitmapPartCollision
/// @sn bitmap:%s cell:%s atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s part:%s
///
/// @class Bitmap
/// @overload CellBitmapCollision CellBitmapPartCollision
/// @csn cell:%s atX:%s y:%s collisionWithBitmap:%s atX:%s y:%s part:%s
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; x1, y1: Single;
bmp2: Bitmap; x2, y2: Single; const part: Rectangle): Boolean; overload;
/// Returns true if the cell in the specified bitmap has collided with a part of a bitmap.
///
/// @lib CellBitmapPartCollisionAtPt
/// @sn bitmap:%s cell:%s at:%s collisionWithBitmap:%s at:%s part:%s
///
/// @class Bitmap
/// @overload CellBitmapCollision CellBitmapPartCollisionAtPt
/// @csn cell:%s at:%s collisionWithBitmap:%s at:%s part:%s
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; const pt1: Point2D;
bmp2: Bitmap; const pt2:Point2D; const part: Rectangle): Boolean; overload;
/// Returns true if the cell of the bitmap has collided with a given rectangle.
///
/// @lib
/// @sn bitmap:%s cell:%s atX:%s y:%s collisionWithRect:%s
///
/// @class Bitmap
/// @method CellRectCollision
/// @csn cell:%s atX:%s y:%s collisionWithRect:%s
function CellRectCollision(bmp: Bitmap; cell: Longint; x, y: Single; const rect: Rectangle): Boolean; overload;
/// Returns true if the cell of the bitmap has collided with a given rectangle.
///
/// @lib CellRectCollisionAtPt
/// @sn bitmap:%s cell:%s at:%s collisionWithRect:%s
///
/// @class Bitmap
/// @method CellRectCollision
/// @csn cell:%s at:%s collisionWithRect:%s
function CellRectCollision(bmp: Bitmap; cell: Longint; const pt: Point2D; const rect: Rectangle): Boolean; overload;
//---------------------------------------------------------------------------
// Geometry Collision Tests
//---------------------------------------------------------------------------
/// Returns True if the Circle collised with rectangle ``rect``.
///
/// @lib
/// @sn circle:%s collisionWithRect:%s
function CircleRectCollision(const c: Circle; const rect: Rectangle): Boolean;
/// Returns True if the circles have collided.
///
/// @lib
/// @sn circle:%s collisionWithCircle:%s
function CircleCircleCollision(const c1, c2: Circle): Boolean;
/// Returns True if the Circle has collided with the Triangle ``tri``.
///
/// @lib
/// @sn circle:%s collisionWithTriangle:%s
function CircleTriangleCollision(const c: Circle; const tri: Triangle): Boolean;
/// Returns true if the triangle and the line have collided.
///
/// @lib
/// @sn triangle:%s collisionWithLine:%s
function TriangleLineCollision(const tri: Triangle; const ln: LineSegment): Boolean;
//---------------------------------------------------------------------------
// Sprite / Geometry Collision Tests
//---------------------------------------------------------------------------
/// Returns True if the `Sprite` ``s``, represented by a bounding circle, has
/// collided with a ``line``. The diameter for the bounding circle is
/// based on the sprites width or height value -- whatever is largest.
///
/// @lib SpriteCircleLineCollision
/// @sn sprite:%s circleCollisionWithLine:%s
function CircleLineCollision(s: Sprite; const line: LineSegment): Boolean;
/// Returns True if the bounding rectangle of the `Sprite` ``s`` has collided
/// with the ``line`` specified.
///
/// @lib SpriteRectLineCollision
/// @sn sprite:%s rectCollisionWithLine:%s
function RectLineCollision(s: Sprite; const line: LineSegment): Boolean; overload;
/// Returns True if the rectangle ``rect`` provided has collided with the
/// ``line``.
///
/// @lib RectLineCollision
/// @sn rectangle:%s collisionWithLine:%s
function RectLineCollision(const rect: Rectangle; const line: LineSegment): Boolean; overload;
//---------------------------------------------------------------------------
// Side to check based on movement direction
//---------------------------------------------------------------------------
/// Returns the side of that needs to be checked for collisions given the
/// movement velocity.
///
/// @lib
function SideForCollisionTest(const velocity: Vector): CollisionSide;
//---------------------------------------------------------------------------
// Collision Effect Application ( angle + energy/mass transfer)
//---------------------------------------------------------------------------
/// Perform a physical collision with a circle bouncing off a line.
///
/// @lib
/// @sn sprite:%s circleCollideWithLine:%s
///
/// @class Sprite
/// @method CircleCollideLine
/// @csn circleCollideWithLine:%s
procedure CollideCircleLine(s: Sprite; const line: LineSegment);
/// Perform a physical collidion with a sprite circle bouncing off a
/// stationary circle.
///
/// @lib
/// @sn sprite:%s circleCollideWithCircle:%s
///
/// @class Sprite
/// @method CircleCollideCircle
/// @csn circleCollideWithCircle:%s
procedure CollideCircleCircle(s: Sprite; const c: Circle);
/// Perform a physical collision with a sprite as a circle bouncing off
/// a stationary rectangle.
///
/// @lib
/// @sn sprite:%s circleCollideWithRect:%s
///
/// @class Sprite
/// @method CircleCollideRectangle
/// @csn circleCollideWithRectangle:%s
procedure CollideCircleRectangle(s: Sprite; const rect: Rectangle); overload;
/// Perform a physical collision with a sprite as a circle bouncing off
/// a stationary triangle.
///
/// @lib
/// @sn sprite:%s circleCollideWithTriangle:%s
///
/// @class Sprite
/// @method CircleCollideTriangle
/// @csn circleCollideWithTriangle:%s
procedure CollideCircleTriangle(s: Sprite; const tri: Triangle); overload;
/// Perform a physical collision between two circular sprites.
///
/// @lib
/// @sn sprite:%s circleCollide:%s
///
/// @class Sprite
/// @method CirclesCollide
/// @csn circlesCollide:%s
procedure CollideCircles(s1, s2: Sprite);
//=============================================================================
implementation
//=============================================================================
uses
SysUtils, sgTrace, sgUtils,
sgGraphics, sgCamera, sgGeometry, sgSprites, sgShared, sgImages, sgBackendTypes, GeometryHelper;
//---------------------------------------------------------------------------
type MyFunc = function (x1, y1, x2, y2: Single): Boolean is nested;
// Step over pixels in the two areas based on the supplied matrix
//
// See http://www.austincc.edu/cchrist1/GAME1343/TransformedCollision/TransformedCollision.htm
function _StepThroughPixels(
w1, h1: Single;
const matrix1: Matrix2D;
w2, h2: Single; //bbox2: Boolean
const matrix2: Matrix2D;
endFn: MyFunc
): Boolean; overload;
var
aIs1: Boolean;
transformAToB: Matrix2D;
hA, wA, hB, wB: Single;
xA, yA, xB, yB: Longint;
stepX, stepY, yPosInB, posInB: Vector;
begin
if w1 * h1 <= w2 * h2 then // use bitmap 1 as the one to scan
begin
aIs1 := true;
hA := h1;
wA := w1;
hB := h2;
wB := w2;
// Calculate a matrix which transforms from 1's local space into
// world space and then into 2's local space
transformAToB := matrix1 * MatrixInverse(matrix2);
end
else // use bitmap 2
begin
aIs1 := false;
hA := h2;
wA := w2;
hB := h1;
wB := w1;
// Calculate a matrix which transforms from 1's local space into
// world space and then into 2's local space
transformAToB := matrix2 * MatrixInverse(matrix1);
end;
// Calculate the top left corner of A in B's local space
// This variable will be reused to keep track of the start of each row
yPosInB := transformAToB * VectorTo(0,0);
// When a point moves in A's local space, it moves in B's local space with a
// fixed direction and distance proportional to the movement in A.
// This algorithm steps through A one pixel at a time along A's X and Y axes
// Calculate the analogous steps in B:
stepX := transformAToB * VectorTo(1, 0) - yPosInB;
stepY := transformAToB * VectorTo(0, 1) - yPosInB;
// Have to check all pixels of one bitmap
// For each row of pixels in A (the smaller)
for yA := 0 to Round(hA) do
begin
posInB := yPosInB;
// For each pixel in this row
for xA := 0 to Round(wA) do
begin
// Calculate this pixel's location in B
// positionInB := transformAToB * VectorTo(xA, yA);
// Round to the nearest pixel
xB := Round(posInB.X);
yB := Round(posInB.Y);
// If the pixel lies within the bounds of B
if (0 <= xB) and (xB < wB) and (0 <= yB) and (yB < hB) then
begin
if ( aIs1 and endFn(xA, yA, xB, yB))
or ((not aIs1) and endFn(xB, yB, xA, yA)) then
begin
result := true;
exit;
end;
end;
// Move to the next pixel in the row
posInB += stepX;
end;
// Move to the next row
yPosInB += stepY;
end;
// No intersection found
result := false;
end;
// See http://www.austincc.edu/cchrist1/GAME1343/TransformedCollision/TransformedCollision.htm
function _CollisionWithinBitmapImagesWithTranslation(
bmp1: Bitmap; w1, h1, offsetX1, offsetY1: Single; //bbox1: Boolean;
const matrix1: Matrix2D;
bmp2: Bitmap; w2, h2, offsetX2, offsetY2: Single; //bbox2: Boolean
const matrix2: Matrix2D
): Boolean; overload;
function _CheckBmps(x1, y1, x2, y2: Single): Boolean;
begin
result :=
PixelDrawnAtPoint(bmp1, x1 + offsetX1, y1 + offsetY1) and PixelDrawnAtPoint(bmp2, x2 + offsetX2, y2 + offsetY2);
end;
begin
result := _StepThroughPixels(w1, h1, matrix1, w2, h2, matrix2, @_CheckBmps);
end;
// Check if part of a bitmap collides with a rect (given the rotation/scaling/translation in the bmpMatrix)
function _BitmapPartRectCollisionWithTranslation(
bmp: Bitmap; const bmpMatrix: Matrix2D; const part, rect: Rectangle): Boolean;
var
matrix2: Matrix2D;
function _CheckBmpVsRect(x1, y1, x2, y2: Single): Boolean;
begin
result :=
PixelDrawnAtPoint(bmp, x1 + part.x, y1 + part.y);
end;
begin
matrix2 := TranslationMatrix(rect.x, rect.y);
result := _StepThroughPixels(part.width, part.height, bmpMatrix, rect.width, rect.height, matrix2, @_CheckBmpVsRect);
end;
function BitmapPartRectCollision(bmp: Bitmap; x, y: Single; const part: Rectangle; const rect: Rectangle): Boolean;
var
i, j: Longint;
left1, right1, left2, right2, overRight, overLeft: Single;
top1, bottom1, top2, bottom2, overTop, overBottom: Single;
yPixel1, xPixel1: Single;
begin
result := false;
if (not assigned(bmp)) or
(not RectanglesIntersect(RectangleFrom(x, y, part.width, part.height), rect)) then exit;
left1 := x;
right1 := x + part.width - 1;
top1 := y;
bottom1 := y + part.height - 1;
left2 := rect.x;
right2 := rect.x + rect.width - 1;
top2 := rect.y;
bottom2 := rect.y + rect.height - 1;
if bottom1 > bottom2 then overBottom := bottom2
else overBottom := bottom1;
if top1 < top2 then overTop := top2
else overTop := top1;
if right1 > right2 then overRight := right2
else overRight := right1;
if left1 < left2 then overLeft := left2
else overLeft := left1;
for i := Round(overTop) to Round(overBottom) do
begin
yPixel1 := i - top1 + part.y;
for j := Round(overLeft) to Round(overRight) do
begin
xPixel1 := j - left1 + part.x;
if PixelDrawnAtPoint(bmp, xPixel1, yPixel1) then
begin
result := true;
exit;
end;
end;
end;
end;
function BitmapRectCollision(bmp: Bitmap; x, y: Single; const rect: Rectangle): Boolean; overload;
begin
result := BitmapPartRectCollision(bmp, x, y, BitmapRectangle(0, 0, bmp), rect);
end;
function BitmapRectCollision(bmp: Bitmap; x, y: Single; const part, rect: Rectangle): Boolean; overload;
begin
result := BitmapPartRectCollision(bmp, x, y, part, rect);
end;
function BitmapRectCollision(bmp: Bitmap; const pt:Point2D; const part, rect: Rectangle): Boolean; overload;
begin
result := BitmapPartRectCollision(bmp, pt.x, pt.y, part, rect);
end;
function BitmapRectCollision(bmp: Bitmap; x, y, rectX, rectY, rectWidth, rectHeight: Single): Boolean; overload;
begin
result := BitmapRectCollision(bmp, x, y, RectangleFrom(rectX, rectY, rectWidth, rectHeight));
end;
function SpriteRectCollision(s: Sprite; x, y, width, height: Single): Boolean; overload;
begin
result := SpriteRectCollision(s, RectangleFrom(x, y, width, height));
end;
function SpriteAtPoint(s: Sprite; const pt: Point2D): Boolean; overload;
begin
result := SpriteRectCollision(s, RectangleFrom(pt, 1, 1));
end;
function SpriteRectCollision(s: Sprite; const r: Rectangle): Boolean; overload;
var
rect: Rectangle;
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
result := false;
if sp = nil then exit;
rect := r;
FixRectangle(rect);
// if (width < 1) or (height < 1) then exit;
if not CircleRectCollision(SpriteCollisionCircle(s), rect) then
exit;
// Check pixel level details
if SpriteCollisionKind(s) = AABBCollisions then
result := true
else
begin
if (SpriteRotation(s) <> 0) or (SpriteScale(s) <> 1) then
result := _BitmapPartRectCollisionWithTranslation(sp^.collisionBitmap, SpriteLocationMatrix(sp), SpriteCurrentCellRectangle(sp), rect)
else
result := CellRectCollision(sp^.collisionBitmap, SpriteCurrentCell(s), sp^.position.x, sp^.position.y, rect);
end;
end;
/// Performs a collision detection within two bitmaps at the given x, y
/// locations. The bbox values indicate if each bitmap should use per
/// pixel collision detection or a bbox collision detection. This version
/// uses pixel based checking at all times.
///
/// When both bitmaps are using bbox collision the routine checks to see
/// if the bitmap rectangles intersect. If one is bbox and the other is
/// pixel based the routine checks to see if a non-transparent pixel in the
/// pixel based image intersects with the bounds of the bbox image. If
/// both are pixel based, the routine checks to see if two non-transparent
/// pixels collide.
///
/// Note: Bitmaps do not need to actually be drawn on the screen.
///
/// @param bmp1, bmp2: The bitmap images to check for collision
/// @param x1, y1: The x,y location of bmp 1
/// @param bbox1: Indicates if bmp1 should use bbox collision
/// @param x2, y2: The x,y location of bmp 2
/// @param bbox2: Indicates if bmp2 should use bbox collision
///
/// @returns True if the bitmaps collide.
function CollisionWithinBitmapImages(
bmp1: Bitmap; x1, y1, w1, h1, offsetX1, offsetY1: Single; //bbox1: Boolean;
bmp2: Bitmap; x2, y2, w2, h2, offsetX2, offsetY2: Single //bbox2: Boolean
): Boolean; overload;
var
left1, left2, overLeft: Single;
right1, right2, overRight: Single;
top1, top2, overTop: Single;
bottom1, bottom2, overBottom: Single;
i, j: Longint;
xPixel1, yPixel1, xPixel2, yPixel2: Single;
begin
if (bmp1 = nil) or (bmp2 = nil) then begin RaiseException('One or both of the specified bitmaps are nil'); exit; end;
if (w1 < 1) or (h1 < 1) or (w2 < 1) or (h2 < 1) then begin RaiseException('Bitmap width and height must be greater then 0'); exit; end;
result := false;
left1 := x1;
right1 := x1 + w1 - 1;
top1 := y1;
bottom1 := y1 + h1 - 1;
left2 := x2;
right2 := x2 + w2 - 1;
top2 := y2;
bottom2 := y2 + h2 - 1;
if bottom1 > bottom2 then overBottom := bottom2
else overBottom := bottom1;
if top1 < top2 then overTop := top2
else overTop := top1;
if right1 > right2 then overRight := right2
else overRight := right1;
if left1 < left2 then overLeft := left2
else overLeft := left1;
for i := Round(overTop) to Round(overBottom) do
begin
yPixel1 := i - top1 + offsetY1;
yPixel2 := i - top2 + offsetY2;
for j := Round(overLeft) to Round(overRight) do
begin
xPixel1 := j - left1 + offsetX1;
xPixel2 := j - left2 + offsetX2;
if PixelDrawnAtPoint(bmp1, xPixel1, yPixel1) and PixelDrawnAtPoint(bmp2, xPixel2, yPixel2) then
begin
result := true;
exit;
end;
end;
end;
end;
/// Performs a collision detection within two bitmaps at the given x, y
/// locations using per pixel collision detection. This checks to see if
/// two non-transparent pixels collide.
function CollisionWithinBitmapImages(bmp1: Bitmap; x1, y1: Single; bmp2: Bitmap; x2, y2: Single): Boolean; overload;
var
b1, b2: BitmapPtr;
begin
b1 := ToBitmapPtr(bmp1);
b2 := ToBitmapPtr(bmp2);
if (not Assigned(b1)) or (not Assigned(b2)) then result := False
else result := CollisionWithinBitmapImages(
bmp1, x1, y1, b1^.image.surface.width, b1^.image.surface.height, 0, 0,
bmp2, x2, y2, b2^.image.surface.width, b2^.image.surface.height, 0, 0);
end;
function CollisionWithinSpriteImages(s1, s2: Sprite): Boolean;
var
part1, part2: Rectangle;
sp1, sp2: SpritePtr;
begin
sp1 := ToSpritePtr(s1);
sp2 := ToSpritePtr(s2);
if (s1 = nil) or (sp2 = nil) then begin result := false; exit; end;
// Check if either is not using pixel level collisions
if SpriteCollisionKind(s1) = AABBCollisions then
begin
result := SpriteRectCollision(s2, SpriteCollisionRectangle(s1));
exit;
end
else if SpriteCollisionKind(s2) = AABBCollisions then
begin
result := SpriteRectCollision(s1, SpriteCollisionRectangle(s2));
exit;
end;
part1 := SpriteCurrentCellRectangle(s1);
part2 := SpriteCurrentCellRectangle(s2);
if (SpriteRotation(s1) = 0) and (SpriteRotation(s2) = 0) and (SpriteScale(s1) = 1) and (SpriteScale(s2) = 1) then
result := CollisionWithinBitmapImages(
sp1^.collisionBitmap, sp1^.position.x, sp1^.position.y, part1.width, part1.height, part1.x, part1.y,
sp2^.collisionBitmap, sp2^.position.x, sp2^.position.y, part2.width, part2.height, part2.x, part2.y)
else
begin
result := _CollisionWithinBitmapImagesWithTranslation(
sp1^.collisionBitmap, part1.width, part1.height, part1.x, part1.y, SpriteLocationMatrix(sp1),
sp2^.collisionBitmap, part2.width, part2.height, part2.x, part2.y, SpriteLocationMatrix(sp2))
end;
end;
function BitmapCollision(bmp1: Bitmap; x1, y1: Single; bmp2: Bitmap; x2, y2: Single): Boolean; overload;
begin
result := CollisionWithinBitmapImages(bmp1, x1, y1, BitmapWidth(bmp1), BitmapHeight(bmp1), 0, 0,
bmp2, x2, y2, BitmapWidth(bmp2), BitmapHeight(bmp2), 0, 0);
end;
function BitmapCollision(bmp1: Bitmap; const pt1: Point2D; bmp2: Bitmap; const pt2: Point2D): Boolean; overload;
begin
result := BitmapCollision(bmp1, pt1.x, pt1.y,
bmp2, pt2.x, pt2.y);
end;
function BitmapCollision(bmp1: Bitmap; const pt1: Point2D; const part1: Rectangle; bmp2: Bitmap; const pt2: Point2D; const part2: Rectangle): Boolean; overload;
begin
result := BitmapCollision(bmp1, pt1.x, pt1.y,
bmp2, pt2.x, pt2.y);
end;
function SpriteCollision(s1, s2: Sprite): Boolean;
begin
if not CircleCircleCollision(SpriteCircle(s1), SpriteCircle(s2)) then
result := false
else if (SpriteRotation(s1) = 0) and (SpriteRotation(s2) = 0 ) and not RectanglesIntersect(SpriteCollisionRectangle(s1), SpriteCollisionRectangle(s2)) then
result := false
else if (SpriteCollisionKind(s1) = PixelCollisions) or (SpriteCollisionKind(s2) = PixelCollisions) then
result := CollisionWithinSpriteImages(s1, s2)
else
result := true;
end;
function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; const pt: Point2D; const part: Rectangle): Boolean; overload;
var
sp: SpritePtr;
part1: Rectangle;
begin
sp := ToSpritePtr(s);
result := false;
if not assigned(sp) then exit;
if (SpriteCollisionKind(s) = AABBCollisions) then
begin
result := BitmapRectCollision(bmp, pt, part, SpriteCollisionRectangle(s));
exit;
end;
if SpriteRotation(s) <> 0 then
begin
part1 := SpriteCurrentCellRectangle(s);
result := _CollisionWithinBitmapImagesWithTranslation(
sp^.collisionBitmap, part1.width, part1.height, part1.x, part1.y, SpriteLocationMatrix(sp),
bmp, part.width, part.height, part.x, part.y, TranslationMatrix(pt));
end
else
result := CellBitmapCollision(sp^.collisionBitmap, SpriteCurrentCell(s), sp^.position, bmp, pt, part);
end;
/// Determines if a sprite has collided with a bitmap using pixel level
/// collision detection with the bitmap.
///
/// @param s: The sprite to check for collision
/// @param bmp: The bitmap image to check for collision
/// @param x, y: The x,y location of the bitmap
/// @param bbox Indicates if bmp should use bbox collision
///
/// @returns True if the bitmap has collided with the sprite.
///
function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; x, y: Single): Boolean; overload;
begin
result := SpriteBitmapCollision(s, bmp, PointAt(x, y), BitmapRectangle(bmp));
end;
function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; const pt: Point2D): Boolean; overload;
begin
result := SpriteBitmapCollision(s, bmp, pt, BitmapRectangle(bmp));
end;
function TriangleLineCollision(const tri: Triangle; const ln: LineSegment): Boolean;
begin
result := LineIntersectsLines(ln, LinesFrom(tri));
end;
function CircleLineCollision(s: Sprite; const line: LineSegment): Boolean;
var
r: Single;
dist: Single;
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
if not Assigned(s) then
begin
result := false;
exit;
end;
if SpriteWidth(s) > SpriteHeight(s) then
r := SpriteWidth(s) div 2
else
r := SpriteHeight(s) div 2;
dist := PointLineDistance(sp^.position.x + r, sp^.position.y + r, line);
result := dist < r;
end;
function RectLineCollision(const rect: Rectangle; const line: LineSegment): Boolean; overload;
begin
result := LineIntersectsLines(line, LinesFrom(rect)) or PointInRect(line.startPoint, rect);
end;
function RectLineCollision(s: Sprite; const line: LineSegment): Boolean; overload;
begin
result := RectLineCollision(SpriteCollisionRectangle(s), line);
end;
//You need to test for collisions on the ...
function SideForCollisionTest (const velocity: Vector): CollisionSide;
const SMALL = 0.01; //The delta for the check
begin
if velocity.x < -SMALL then //Going Left...
begin
if velocity.y < -SMALL then result := BottomRight
else if velocity.y > SMALL then result := TopRight
else result := Right;
end
else if velocity.x > SMALL then //Going Right
begin
if velocity.y < -SMALL then result := BottomLeft
else if velocity.y > SMALL then result := TopLeft
else result := Left;
end
else // Going Up or Down
begin
if velocity.y < -SMALL then result := Bottom
else if velocity.y > SMALL then result := Top
else result := None;
end;
end;
//----------------------------------------------------------------------------
// Bitmap <--> Point collision detection
//----------------------------------------------------------------------------
function BitmapPointCollision(bmp: Bitmap; x, y: Single; bbox: Boolean; ptX, ptY: Single): Boolean; overload;
begin
if bbox then
result := PointInRect(ptX, ptY, BitmapRectangle(x, y, bmp))
else
result := BitmapPointCollision(bmp, x, y, ptX, ptY);
end;
function BitmapPointCollision(bmp: Bitmap; x, y, ptX, ptY: Single): Boolean; overload;
begin
result := PixelDrawnAtPoint(bmp, ptX - x, ptY - y);
end;
function BitmapPointCollision(bmp: Bitmap; x, y: Single; bbox: Boolean; const pt: Point2D): Boolean; overload;
begin
result := BitmapPointCollision(bmp, x, y, bbox, pt.x, pt.y);
end;
function BitmapPointCollision(bmp: Bitmap; x, y: Single; const pt: Point2D): Boolean; overload;
begin
result := BitmapPointCollision(bmp, x, y, False, pt.x, pt.y);
end;
function BitmapPartPointCollision(bmp: Bitmap; x, y: Single; const part: Rectangle; ptX, ptY: Single): Boolean; overload;
begin
result := BitmapPointCollision(bmp, x, y, False, ptX + part.x, ptY + part.y);
end;
function BitmapPartPointCollision(bmp: Bitmap; x, y: Single; const part: Rectangle; const pt: Point2D): Boolean; overload;
begin
result := BitmapPointCollision(bmp, x, y, False, pt.x + part.x, pt.y + part.y);
end;
//----------------------------------------------------------------------------
// Collision Effect Application (angle + mass/energy transfer)
//----------------------------------------------------------------------------
procedure _CollideCircleLine(s: Sprite; const line: LineSegment);
var
npx, npy, dotPod: Single;
toLine: Vector;
intersect: Point2D;
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
//TODO: fix collision pt.... cast back along velocity...
intersect := ClosestPointOnLine(CenterPoint(s), line);
//DrawSprite(s);
//DrawCircle(ColorRed, intersect, 2);
toLine := UnitVector(VectorFromCenterSpriteToPoint(s, intersect));
// Project velocity across to-line
dotPod := - DotProduct(toLine, sp^.velocity);
npx := dotPod * toLine.x;
npy := dotPod * toLine.y;
sp^.velocity.x := sp^.velocity.x + 2 * npx;
sp^.velocity.y := sp^.velocity.y + 2 * npy;
//DrawLine(ColorYellow, CenterPoint(s).x, CenterPoint(s).y, CenterPoint(s).x + (sp^.velocity.x * 10), CenterPoint(s).y + (sp^.velocity.y * 10));
//RefreshScreen(1) ;
end;
procedure CollideCircleLines(s: Sprite; const lines: LinesArray);
var
outVec, mvmt: Vector;
maxIdx: Longint;
mvmtMag, prop: Single;
var
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
if not Assigned(sp) then exit;
mvmt := sp^.velocity;
maxIdx := -1;
outVec := VectorOverLinesFromCircle(SpriteCollisionCircle(s), lines, mvmt, maxIdx);
if maxIdx < 0 then exit;
MoveSprite(s, outVec);
_CollideCircleLine(s, lines[maxIdx]);
// do part velocity
mvmtMag := VectorMagnitude(mvmt);
prop := VectorMagnitude(outVec) / mvmtMag; //proportion of move "undone" by back out
if prop > 0 then MoveSprite(s, prop); //TODO: Allow proportion of move to be passed in (overload)... then do velocity based on prop * pct
end;
procedure CollideCircleLine(s: Sprite; const line: LineSegment);
var
lines: LinesArray;
begin
SetLength(lines, 1);
lines[0] := line;
CollideCircleLines(s, lines);
end;
procedure CollideCircles(s1, s2: Sprite);
var
c1, c2: Circle;
colNormalAngle, a1, a2, optP, s1Mass, s2Mass: Single;
n: Vector;
sp1, sp2: SpritePtr;
begin
s1Mass := SpriteMass(s1);
s2Mass := SpriteMass(s2);
if (s1Mass <= 0) or (s2Mass <= 0) then begin RaiseWarning('Collision with 0 or negative mass... ensure that mass is greater than 0'); exit; end;
sp1 := ToSpritePtr(s1);
sp2 := ToSpritePtr(s2);
c1 := SpriteCollisionCircle(s1);
c2 := SpriteCollisionCircle(s2);
//if s1^.mass < s2^.mass then
if VectorMagnitude(sp1^.velocity) > VectorMagnitude(sp2^.velocity) then
begin
//move s1 out
n := VectorOutOfCircleFromCircle(c1, c2, sp1^.velocity);
sp1^.position.x := sp1^.position.x + n.x;
sp1^.position.y := sp1^.position.y + n.y;
end
else
begin
//move s2 out
n := VectorOutOfCircleFromCircle(c2, c1, sp2^.velocity);
sp2^.position.x := sp2^.position.x + n.x;
sp2^.position.y := sp2^.position.y + n.y;
end;
colNormalAngle := CalculateAngle(s1, s2);
// COLLISION RESPONSE
// n = vector connecting the centers of the balls.
// we are finding the components of the normalised vector n
n := VectorTo(Cosine(colNormalAngle), Sine(colNormalAngle));
// now find the length of the components of each velocity vectors
// along n, by using dot product.
a1 := DotProduct(sp1^.velocity, n);
// Local a1# = c.dx*nX + c.dy*nY
a2 := DotProduct(sp2^.velocity, n);
// Local a2# = c2.dx*nX + c2.dy*nY
// optimisedP = 2(a1 - a2)
// ----------
// m1 + m2
optP := (2.0 * (a1-a2)) / (s1Mass + s2Mass);
// now find out the resultant vectors
// Local r1% = c1.v - optimisedP * mass2 * n
sp1^.velocity.x := sp1^.velocity.x - (optP * s2Mass * n.x);
sp1^.velocity.y := sp1^.velocity.y - (optP * s2Mass * n.y);
// Local r2% = c2.v - optimisedP * mass1 * n
sp2^.velocity.x := sp2^.velocity.x + (optP * s1Mass * n.x);
sp2^.velocity.y := sp2^.velocity.y + (optP * s1Mass * n.y);
end;
procedure CollideCircleCircle(s: Sprite; const c: Circle);
var
hitLine: LineSegment;
outVec, mvmt, normal, colVec: Vector;
mvmtMag, prop: Single;
spriteCenter, hitPt: Point2D;
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
if not Assigned(sp) then exit;
//TODO: what if height > width!!
spriteCenter := CenterPoint(s);
mvmt := sp^.velocity;
// A not moving sprite cannot "collide" as it is stationary
// We are then unable to determine where the collision did
// occur...
if VectorMagnitude(mvmt) = 0 then
begin
RaiseWarning('Attempting to perform sprite collision without sprite velocity.');
exit;
end;
outVec := VectorOutOfCircleFromCircle(SpriteCollisionCircle(s), c, mvmt);
// Back out of circle
MoveSprite(s, outVec);
// Normal of the collision...
colVec := UnitVector(VectorFromPoints(c.center, spriteCenter));
normal := VectorNormal(colVec);
hitPt := AddVectors(c.center, VectorMultiply(colVec, Single(c.radius + 1.42)));
hitLine := LineFromVector(AddVectors(hitPt, VectorMultiply(normal, 100)), VectorMultiply(normal, -200));
// DrawSprite(s);
// DrawLine(ColorWhite, hitLine);
// RefreshScreen(1);
_CollideCircleLine(s, hitLine);
// do part velocity
mvmtMag := VectorMagnitude(mvmt);
prop := VectorMagnitude(outVec) / mvmtMag; //proportion of move "undone" by back out
if prop > 0 then MoveSprite(s, prop); //TODO: Allow proportion of move to be passed in (overload)... then do velocity based on prop * pct
end;
//TODO: bounds based checking, need VectorIntoShape...
procedure CollideCircleRectangle(s: Sprite; const rect: Rectangle; bounds: Boolean); overload;
var
hitIdx: Longint;
lines: LinesArray;
outVec, mvmt: Vector;
mvmtMag, prop: Single;
sp: SpritePtr;
begin
sp := ToSpritePtr(s);
if not Assigned(sp) then exit;
mvmt := sp^.velocity;
hitIdx := -1;
// Get the line hit...
lines := LinesFrom(rect);
outVec := VectorOverLinesFromCircle(SpriteCollisionCircle(s), lines, mvmt, hitIdx);
if hitIdx = -1 then exit;
// back out of rectangle
MoveSprite(s, outVec);
// bounce...
_CollideCircleLine(s, lines[hitIdx]);
// do part velocity
mvmtMag := VectorMagnitude(mvmt);
prop := VectorMagnitude(outVec) / mvmtMag; //proportion of move "undone" by back out
if prop > 0 then MoveSprite(s, prop); //TODO: Allow proportion of move to be passed in (overload)... then do velocity based on prop * pct
end;
procedure CollideCircleRectangle(s: Sprite; const rect: Rectangle); overload;
begin
CollideCircleRectangle(s, rect, False);
end;
procedure CollideCircleRectangleBounds(s: Sprite; const rect: Rectangle);
begin
CollideCircleRectangle(s, rect, True);
end;
procedure CollideCircleTriangle(s: Sprite; const tri: Triangle); overload;
var
lines: LinesArray;
begin
lines := LinesFrom(tri);
CollideCircleLines(s, lines);
end;
//----------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Geometry Collision Tests
//---------------------------------------------------------------------------
function CircleLinesCollision(const c: Circle; const lines: LinesArray): Boolean;
var
pt: Point2D;
i: Longint;
begin
result := False;
for i := 0 to High(lines) do
begin
pt := ClosestPointOnLineFromCircle(c, lines[i]);
if PointPointDistance(c.center, pt) <= c.radius then
begin
//DrawCircle(ColorGreen, pt, 2);
result := True;
exit;
end;
end;
end;
function CircleRectCollision(const c: Circle; const rect: Rectangle): Boolean;
begin
if CircleLinesCollision(c, LinesFrom(rect)) then result := True
else
result := PointInRect(c.center, rect.x, rect.y, rect.width, rect.height)
or PointInCircle( PointAt(rect.x, rect.y), c);
end;
function CircleCircleCollision(const c1, c2: Circle): Boolean;
begin
result := PointPointDistance(c1.center, c2.center) < c1.radius + c2.radius;
end;
function CircleTriangleCollision(const c: Circle; const tri: Triangle): Boolean;
var
i: Longint;
begin
result := False;
for i := 0 to 2 do
begin
// if the closest point on the circle is in the triangle, or the triangle pt is in the circle
if PointInTriangle(ClosestPointOnCircle(tri.points[i], c), tri) or PointInCircle(tri.points[i], c) then
begin
result := True;
exit;
end;
end;
end;
//---------------------------------------------------------------------------
function CellCollision( bmp1: Bitmap; cell1: Longint; x1, y1: Single;
bmp2: Bitmap; cell2: Longint; x2, y2: Single): Boolean;
var
r1, r2: Rectangle;
begin
r1 := BitmapRectangleOfCell(bmp1, cell1);
r2 := BitmapRectangleOfCell(bmp2, cell2);
result :=
CollisionWithinBitmapImages(bmp1, x1, y1, r1.width, r1.height, r1.x, r1.y,
bmp2, x2, y2, r2.width, r2.height, r2.x, r2.y);
end;
function CellCollision( bmp1: Bitmap; cell1: Longint; const pt1: Point2D;
bmp2: Bitmap; cell2: Longint; const pt2: Point2D): Boolean;
begin
result := CellCollision(bmp1, cell1, pt1.x, pt1.y,
bmp2, cell2, pt2.x, pt2.y);
end;
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; x1, y1: Single;
bmp2: Bitmap; x2, y2: Single): Boolean; overload;
begin
result := CellBitmapCollision( bmp1, cell, x1, y1,
bmp2, x2, y2, BitmapRectangle(0, 0, bmp2));
end;
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; const pt1: Point2D;
bmp2: Bitmap; const pt2: Point2D): Boolean; overload;
begin
result := CellBitmapCollision( bmp1, cell, pt1.x, pt1.y,
bmp2, pt2.x, pt2.y);
end;
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; x1, y1: Single;
bmp2: Bitmap; x2, y2: Single; const part: Rectangle): Boolean; overload;
var
r1: Rectangle;
begin
if not assigned(bmp2) then
begin
result := false;
exit;
end;
r1 := BitmapRectangleOfCell(bmp1, cell);
result :=
CollisionWithinBitmapImages(bmp1, x1, y1, r1.width, r1.height, r1.x, r1.y,
bmp2, x2, y2, part.width, part.height, part.x, part.y);
end;
function CellBitmapCollision(bmp1: Bitmap; cell: Longint; const pt1: Point2D;
bmp2: Bitmap; const pt2:Point2D; const part: Rectangle): Boolean; overload;
begin
result := CellBitmapCollision( bmp1, cell, pt1.x, pt1.y,
bmp2, pt2.x, pt2.y, part);
end;
function CellRectCollision(bmp: Bitmap; cell: Longint; x, y: Single; const rect: Rectangle): Boolean; overload;
var
r1: Rectangle;
begin
r1 := BitmapRectangleOfCell(bmp, cell);
result := BitmapPartRectCollision(bmp, x, y, r1, rect);
end;
function CellRectCollision(bmp: Bitmap; cell: Longint; const pt: Point2D; const rect: Rectangle): Boolean; overload;
begin
result := CellRectCollision(bmp, cell, pt.x, pt.y, rect);
end;
end.
|
unit TestRedisClientU;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, System.Variants, IdTCPClient, Winapi.Windows, Vcl.Dialogs,
Vcl.Forms, IdTCPConnection, Vcl.Controls, System.Classes, System.SysUtils,
IdComponent, Winapi.Messages, IdBaseComponent, Vcl.Graphics, Vcl.StdCtrls,
Redis.Client, Redis.Commons;
type
// Test methods for class IRedisClient
TestRedisClient = class(TTestCase)
strict private
FRedis: IRedisClient;
private
Res: string;
ArrRes: TArray<string>;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestCommandParser;
procedure TestExecuteWithStringArrayResponse;
procedure TestSetGet;
procedure TestSetGetUnicode;
procedure TestAPPEND;
procedure TestSTRLEN;
procedure TestGETRANGE;
procedure TestSETRANGE;
procedure TestMSET;
procedure TestINCR_DECR;
procedure TestEXPIRE;
procedure TestDelete;
procedure TestRPUSH_RPOP;
procedure TestRPUSHX_LPUSHX;
procedure TestLPUSH_LPOP;
procedure TestLRANGE;
procedure TestLLEN;
procedure TestLTRIM;
procedure TestZADD_ZRANK_ZCARD;
procedure TestRPOPLPUSH;
procedure TestBRPOPLPUSH;
procedure TestBLPOP;
procedure TestBRPOP;
procedure TestLREM;
procedure TestSELECT;
procedure TestMULTI;
procedure TestHSetHGet;
procedure TestHMSetHMGet;
procedure TestHMGetBUGWithEmptyValues;
procedure TestAUTH;
procedure TestHSetHGet_Bytes;
procedure TestWATCH_MULTI_EXEC_OK;
procedure TestWATCH_MULTI_EXEC_Fail;
procedure TestWATCH_OK;
procedure TestWATCH_Fail;
// procedure TestSUBSCRIBE;
end;
implementation
uses system.rtti;
procedure TestRedisClient.SetUp;
begin
FRedis := NewRedisClient('localhost', 6379, False, 'indy');
end;
procedure TestRedisClient.TearDown;
begin
FRedis := nil;
end;
procedure TestRedisClient.TestAPPEND;
var
lValue: string;
Value: TValue;
begin
FRedis.DEL(['mykey']);
CheckEquals(4, FRedis.APPEND('mykey', '1234'), 'Wrong length');
CheckEquals(8, FRedis.APPEND('mykey', '5678'), 'Wrong length');
CheckTrue(FRedis.GET('mykey', lValue), 'Key doesn''t exist');
CheckEquals('12345678', lValue, 'Wrong key value...');
end;
procedure TestRedisClient.TestAUTH;
begin
// the TEST Redis instance is not protected with a password
ExpectedException := ERedisException;
FRedis.AUTH('foo');
end;
procedure TestRedisClient.TestBLPOP;
begin
// setup list
FRedis.DEL(['mylist']);
FRedis.RPUSH('mylist', ['one', 'two']);
// pop from a non-empty list
CheckTrue(FRedis.BLPOP(['mylist'], 1, ArrRes));
CheckEquals('mylist', ArrRes[0]);
CheckEquals('one', ArrRes[1]);
// pop from a non-empty list
CheckTrue(FRedis.BLPOP(['mylist'], 1, ArrRes));
CheckEquals('mylist', ArrRes[0]);
CheckEquals('two', ArrRes[1]);
// pop from a empty list, check the timeout
CheckFalse(FRedis.BLPOP(['mylist'], 1, ArrRes));
CheckEquals(0, Length(ArrRes));
// now, test if it works when another thread pushes a values into the list
TThread.CreateAnonymousThread(
procedure
var
Redis: IRedisClient;
begin
Redis := NewRedisClient('localhost');
Redis.RPUSH('mylist', ['from', 'another', 'thread']);
end).Start;
CheckTrue(FRedis.BLPOP(['mylist'], 10, ArrRes));
CheckEquals(2, Length(ArrRes));
end;
procedure TestRedisClient.TestBRPOP;
begin
// setup list
FRedis.DEL(['mylist']);
FRedis.RPUSH('mylist', ['one', 'two']);
// pop from a non-empty list
CheckTrue(FRedis.BRPOP(['mylist'], 1, ArrRes));
CheckEquals('mylist', ArrRes[0]);
CheckEquals('two', ArrRes[1]);
// pop from a non-empty list
CheckTrue(FRedis.BRPOP(['mylist'], 1, ArrRes));
CheckEquals('mylist', ArrRes[0]);
CheckEquals('one', ArrRes[1]);
// pop from a empty list, check the timeout
CheckFalse(FRedis.BRPOP(['mylist'], 1, ArrRes));
CheckEquals(0, Length(ArrRes));
// now, test if it works when another thread pushes a values into the list
TThread.CreateAnonymousThread(
procedure
var
Redis: IRedisClient;
begin
Redis := NewRedisClient('localhost');
Redis.RPUSH('mylist', ['from', 'another', 'thread']);
end).Start;
CheckTrue(FRedis.BRPOP(['mylist'], 10, ArrRes));
CheckEquals(2, Length(ArrRes));
end;
procedure TestRedisClient.TestBRPOPLPUSH;
var
Value: string;
begin
FRedis.DEL(['mylist', 'myotherlist']);
CheckFalse(FRedis.BRPOPLPUSH('mylist', 'myotherlist', Value, 1));
CheckEquals('', Value);
FRedis.RPUSH('mylist', ['one', 'two']);
CheckTrue(FRedis.BRPOPLPUSH('mylist', 'myotherlist', Value, 1));
CheckEquals('two', Value);
CheckTrue(FRedis.RPOP('myotherlist', Value));
CheckEquals('two', Value);
CheckTrue(FRedis.BRPOPLPUSH('mylist', 'myotherlist', Value, 1));
CheckEquals('one', Value);
CheckTrue(FRedis.RPOP('myotherlist', Value));
CheckEquals('one', Value);
CheckFalse(FRedis.BRPOPLPUSH('mylist', 'myotherlist', Value, 1));
CheckEquals('', Value);
end;
procedure TestRedisClient.TestCommandParser;
procedure CheckSimpleSet;
begin
CheckEquals('set', ArrRes[0]);
CheckEquals('nome', ArrRes[1]);
CheckEquals('daniele', ArrRes[2]);
end;
procedure CheckSimpleSet2;
begin
CheckEquals('set', ArrRes[0]);
CheckEquals('no me', ArrRes[1]);
CheckEquals('da ni\ele', ArrRes[2]);
end;
begin
ArrRes := FRedis.Tokenize('set nome daniele');
CheckSimpleSet;
ArrRes := FRedis.Tokenize('set nome daniele');
CheckSimpleSet;
ArrRes := FRedis.Tokenize(' set "nome" daniele ');
CheckSimpleSet;
ArrRes := FRedis.Tokenize(' set "nome" "daniele" ');
CheckSimpleSet;
ArrRes := FRedis.Tokenize('set nome "daniele"');
CheckSimpleSet;
ArrRes := FRedis.Tokenize('set "no me" "da ni\ele"');
CheckSimpleSet2;
ExpectedException := ERedisException;
ArrRes := FRedis.Tokenize('set nome "daniele');
end;
procedure TestRedisClient.TestDelete;
begin
FRedis.&SET('NOME', 'Daniele');
FRedis.&SET('COGNOME', 'Teti');
CheckEquals(1, FRedis.DEL(['NOME']));
CheckFalse(FRedis.GET('NOME', Res));
CheckTrue(FRedis.GET('COGNOME', Res));
end;
procedure TestRedisClient.TestExecuteWithStringArrayResponse;
var
Cmd: IRedisCommand;
begin
FRedis.FLUSHDB;
Cmd := NewRedisCommand('keys');
Cmd.Add('*o*');
CheckEquals(0, Length(FRedis.ExecuteAndGetArray(Cmd)));
FRedis.&SET('1one', '1');
FRedis.&SET('2one', '2');
CheckEquals(2, Length(FRedis.ExecuteAndGetArray(Cmd)));
end;
procedure TestRedisClient.TestEXPIRE;
var
v: string;
begin
FRedis.&SET('daniele', '1234');
FRedis.EXPIRE('daniele', 1);
FRedis.GET('daniele', v);
CheckEquals('1234', v);
TThread.Sleep(1100);
CheckFalse(FRedis.GET('daniele', v));
end;
procedure TestRedisClient.TestGETRANGE;
begin
FRedis.DEL(['mykey']);
CheckEquals('', FRedis.GETRANGE('mykey', 0, 1));
FRedis.&SET('mykey', '0123456789');
CheckEquals('0', FRedis.GETRANGE('mykey', 0, 0));
CheckEquals('01', FRedis.GETRANGE('mykey', 0, 1));
CheckEquals('12', FRedis.GETRANGE('mykey', 1, 2));
CheckEquals('0123456789', FRedis.GETRANGE('mykey', 0, -1));
CheckEquals('456789', FRedis.GETRANGE('mykey', 4, -1));
CheckEquals('45678', FRedis.GETRANGE('mykey', 4, -2));
CheckEquals('', FRedis.GETRANGE('mykey', 4, 2));
end;
procedure TestRedisClient.TestHMGetBUGWithEmptyValues;
var
Values: TArray<string>;
begin
FRedis.HSET('abc', 'Name', 'Daniele Teti');
FRedis.HSET('abc', 'Address', '');
FRedis.HSET('abc', 'Postcode', '12345');
// there was an access violation here
Values := FRedis.HMGET('abc', VarArrayOf(['Name', 'Address', 'Postcode']));
CheckEquals('Daniele Teti', Values[0]);
CheckEquals('', Values[1]);
CheckEquals('12345', Values[2]);
end;
procedure TestRedisClient.TestHMSetHMGet;
const
C_KEY = 'thekey';
var
lValues: TArray<string>;
begin
FRedis.DEL([C_KEY]);
FRedis.HMSET(C_KEY, VarArrayOf(['field1', 'field2', 'field3']),
VarArrayOf(['value1', 'value2', 'value3']));
lValues := FRedis.HMGET(C_KEY, VarArrayOf(['field1', 'field2', 'field3']));
CheckEqualsString('value1', lValues[0]);
CheckEqualsString('value2', lValues[1]);
CheckEqualsString('value3', lValues[2]);
end;
procedure TestRedisClient.TestHSetHGet;
var
aResult: string;
begin
FRedis.DEL(['mykey']);
FRedis.HSET('mykey', 'first_name', 'Daniele');
FRedis.HSET('mykey', 'last_name', 'Teti');
FRedis.HGET('mykey', 'first_name', aResult);
CheckEqualsString('Daniele', aResult);
FRedis.HGET('mykey', 'last_name', aResult);
CheckEqualsString('Teti', aResult);
end;
procedure TestRedisClient.TestHSetHGet_Bytes;
const
C_KEY = 'mykey';
C_field = 'name';
C_VALUE = 'Daniele';
var
aResult: Tbytes;
begin
FRedis.DEL([C_KEY]);
FRedis.HSET(C_KEY, C_field, C_VALUE);
FRedis.HGET(C_KEY, C_field, aResult);
CheckEqualsString(C_VALUE, StringOf(aResult));
end;
procedure TestRedisClient.TestINCR_DECR;
begin
FRedis.&SET('daniele', '-1');
CheckEquals(0, FRedis.INCR('daniele'));
FRedis.&SET('daniele', '1');
CheckEquals(2, FRedis.INCR('daniele'));
CheckEquals(1, FRedis.DECR('daniele'));
FRedis.DEL(['daniele']);
CheckEquals(-1, FRedis.DECR('daniele'));
end;
procedure TestRedisClient.TestLLEN;
begin
FRedis.DEL(['mylist']);
CheckEquals(0, FRedis.LLEN('mylist'));
FRedis.RPUSH('mylist', ['one', 'two']);
CheckEquals(2, FRedis.LLEN('mylist'));
FRedis.&SET('myvalue', '3');
ExpectedException := ERedisException;
FRedis.LLEN('myvalue');
end;
procedure TestRedisClient.TestLPUSH_LPOP;
var
Value: string;
begin
FRedis.DEL(['mylist']);
FRedis.LPUSH('mylist', ['one', 'two', 'three']);
CheckTrue(FRedis.LPOP('mylist', Value));
CheckEquals('three', Value);
CheckTrue(FRedis.LPOP('mylist', Value));
CheckEquals('two', Value);
CheckTrue(FRedis.LPOP('mylist', Value));
CheckEquals('one', Value);
CheckFalse(FRedis.LPOP('mylist', Value))
end;
procedure TestRedisClient.TestLRANGE;
begin
FRedis.DEL(['mylist']);
FRedis.RPUSH('mylist', ['one', 'two', 'three', 'four', 'five']);
ArrRes := FRedis.LRANGE('mylist', 0, 1);
CheckEquals(2, Length(ArrRes));
CheckEquals('one', ArrRes[0]);
CheckEquals('two', ArrRes[1]);
ArrRes := FRedis.LRANGE('mylist', -1, -1);
CheckEquals(1, Length(ArrRes));
CheckEquals('five', ArrRes[0]);
ArrRes := FRedis.LRANGE('mylist', 0, 20);
CheckEquals(5, Length(ArrRes));
CheckEquals('one', ArrRes[0]);
CheckEquals('two', ArrRes[1]);
CheckEquals('three', ArrRes[2]);
CheckEquals('four', ArrRes[3]);
CheckEquals('five', ArrRes[4]);
ArrRes := FRedis.LRANGE('notexists', 0, 20);
CheckEquals(0, Length(ArrRes));
end;
procedure TestRedisClient.TestLREM;
begin
FRedis.DEL(['mylist']);
FRedis.RPUSH('mylist', ['hello', 'hello', 'foo', 'hello']);
FRedis.LREM('mylist', -2, 'hello');
ArrRes := FRedis.LRANGE('mylist', 0, -1);
CheckEquals('hello', ArrRes[0]);
CheckEquals('foo', ArrRes[1]);
end;
procedure TestRedisClient.TestLTRIM;
begin
FRedis.DEL(['mylist']);
CheckEquals(0, FRedis.LLEN('mylist'));
FRedis.RPUSH('mylist', ['one', 'two', 'three', 'four', 'five']);
CheckEquals(5, FRedis.LLEN('mylist'));
FRedis.LTRIM('mylist', 0, 2);
CheckEquals(3, FRedis.LLEN('mylist'));
FRedis.LTRIM('mylist', 1, -2);
CheckEquals(1, FRedis.LLEN('mylist'));
FRedis.LTRIM('mylist', 10, -10);
CheckEquals(0, FRedis.LLEN('mylist'));
end;
procedure TestRedisClient.TestMSET;
begin
FRedis.FLUSHDB;
CheckTrue(FRedis.MSET(['one', '1', 'two', '2', 'three', '3']));
ArrRes := FRedis.KEYS('*e*');
CheckEquals(2, Length(ArrRes));
end;
procedure TestRedisClient.TestMULTI;
var
v: string;
begin
ArrRes := FRedis.MULTI(
procedure(const Redis: IRedisClient)
begin
Redis.&SET('name', 'Daniele');
Redis.DEL(['name']);
end);
CheckEquals('OK', ArrRes[0]);
CheckEquals('1', ArrRes[1]);
CheckFalse(FRedis.GET('name', v));
end;
procedure TestRedisClient.TestRPOPLPUSH;
var
Value: string;
begin
FRedis.DEL(['mylist', 'myotherlist']);
CheckFalse(FRedis.RPOPLPUSH('mylist', 'myotherlist', Value));
CheckEquals('', Value);
FRedis.RPUSH('mylist', ['one', 'two']);
CheckTrue(FRedis.RPOPLPUSH('mylist', 'myotherlist', Value));
CheckEquals('two', Value);
CheckTrue(FRedis.RPOP('myotherlist', Value));
CheckEquals('two', Value);
CheckTrue(FRedis.RPOPLPUSH('mylist', 'myotherlist', Value));
CheckEquals('one', Value);
CheckTrue(FRedis.RPOP('myotherlist', Value));
CheckEquals('one', Value);
CheckFalse(FRedis.RPOPLPUSH('mylist', 'myotherlist', Value));
CheckEquals('', Value);
end;
procedure TestRedisClient.TestRPUSHX_LPUSHX;
begin
FRedis.DEL(['mylist']);
// mylist doesn't exists, so RPUSHX doesn't create it.
CheckEquals(0, FRedis.RPUSHX('mylist', ['one']));
CheckEquals(0, FRedis.LLEN('mylist'));
// RPUSH creates mylist
CheckEquals(1, FRedis.RPUSH('mylist', ['one']));
CheckEquals(1, FRedis.LLEN('mylist'));
// RPUSHX append to the list
CheckEquals(2, FRedis.RPUSHX('mylist', ['two']));
FRedis.DEL(['mylist']);
CheckEquals(0, FRedis.LPUSHX('mylist', ['one']));
CheckEquals(0, FRedis.LLEN('mylist'));
end;
procedure TestRedisClient.TestRPUSH_RPOP;
var
Value: string;
begin
FRedis.DEL(['mylist']);
FRedis.RPUSH('mylist', ['one', 'two', 'three']);
CheckTrue(FRedis.RPOP('mylist', Value));
CheckEquals('three', Value);
CheckTrue(FRedis.RPOP('mylist', Value));
CheckEquals('two', Value);
CheckTrue(FRedis.RPOP('mylist', Value));
CheckEquals('one', Value);
CheckEquals(False, FRedis.RPOP('mylist', Value));
end;
procedure TestRedisClient.TestSELECT;
var
v: string;
begin
FRedis.SELECT(0);
FRedis.&SET('db0', 'value0');
FRedis.SELECT(1);
CheckFalse(FRedis.GET('db0', v));
FRedis.SELECT(0);
FRedis.GET('db0', v);
CheckEquals('value0', v);
end;
procedure TestRedisClient.TestSetGet;
var
Res: string;
begin
CheckTrue(FRedis.&SET('nome', 'Daniele'));
FRedis.GET('nome', Res);
CheckEquals('Daniele', Res);
CheckTrue(FRedis.&SET('no"me', 'Dan"iele'));
CheckTrue(FRedis.GET('no"me', Res));
CheckEquals('Dan"iele', Res);
CheckTrue(FRedis.&SET('no"me', 'Dan iele'));
CheckTrue(FRedis.GET('no"me', Res));
CheckEquals('Dan iele', Res);
end;
procedure TestRedisClient.TestSetGetUnicode;
var
Res: string;
const
NonStdASCIIValue = 'אטילעשח@§°`';
begin
CheckTrue(FRedis.&SET('nome', NonStdASCIIValue));
CheckTrue(FRedis.GET('nome', Res));
CheckEquals(NonStdASCIIValue, Res);
end;
procedure TestRedisClient.TestSETRANGE;
var
lValue: string;
lBytesValue: TArray<Byte>;
begin
FRedis.&SET('mykey', '00112233445566778899');
CheckEquals(20, FRedis.SETRANGE('mykey', 0, 'XX'));
FRedis.GET('mykey', lValue);
CheckEquals('XX112233445566778899', lValue);
FRedis.&SET('mykey', '00112233445566778899');
CheckEquals(20, FRedis.SETRANGE('mykey', 2, 'XX'));
FRedis.GET('mykey', lValue);
CheckEquals('00XX2233445566778899', lValue);
FRedis.&SET('mykey', '00112233445566778899');
CheckEquals(20, FRedis.SETRANGE('mykey', 18, 'XX'));
FRedis.GET('mykey', lValue);
CheckEquals('001122334455667788XX', lValue);
FRedis.DEL(['mykey']);
CheckEquals(4, FRedis.SETRANGE('mykey', 2, 'XY'));
FRedis.GET('mykey', lBytesValue);
CheckEquals('00', ByteToHex(lBytesValue[0])); // padded bytes are $00
CheckEquals('00', ByteToHex(lBytesValue[1])); // padded bytes are $00
CheckEquals(IntToHex(Ord('X'), 2), ByteToHex(lBytesValue[2]));
CheckEquals(IntToHex(Ord('Y'), 2), ByteToHex(lBytesValue[3]));
end;
procedure TestRedisClient.TestSTRLEN;
begin
FRedis.DEL(['mykey']);
CheckEquals(0, FRedis.STRLEN('mykey'), 'Len of a not exists key is not zero');
FRedis.APPEND('mykey', '1234');
CheckEquals(4, FRedis.STRLEN('mykey'), 'Wrong length');
FRedis.APPEND('mykey', '5678');
CheckEquals(8, FRedis.STRLEN('mykey'), 'Wrong length');
end;
procedure TestRedisClient.TestWATCH_Fail;
var
lValue: string;
lOtherClient: IRedisClient;
begin
lOtherClient := NewRedisClient;
FRedis.&SET('mykey', '1234');
FRedis.WATCH(['mykey']);
FRedis.GET('mykey', lValue);
lOtherClient.&SET('mykey', '1111'); // another client change the watched key!
ExpectedException := ERedisException;
FRedis.MULTI(
procedure(const R: IRedisClient)
begin
R.&SET('mykey', IntToStr(StrToInt(lValue) + 1));
end);
end;
procedure TestRedisClient.TestWATCH_MULTI_EXEC_OK;
var
lValue: string;
lResp: TArray<string>;
begin
FRedis.&SET('mykey', '1234');
FRedis.WATCH(['mykey']);
FRedis.GET('mykey', lValue);
FRedis.MULTI;
CheckTrue(FRedis.InTransaction, 'Is not in transaction when it should');
FRedis.&SET('mykey', IntToStr(StrToInt(lValue) + 1));
lResp := FRedis.EXEC;
Check(Length(lResp) = 1);
Check(lResp[0] = 'OK');
CheckFalse(FRedis.InTransaction, 'Is in transaction when it should not');
end;
procedure TestRedisClient.TestWATCH_MULTI_EXEC_Fail;
var
lValue: string;
lOtherClient: IRedisClient;
begin
lOtherClient := NewRedisClient;
FRedis.&SET('mykey', '1234');
FRedis.WATCH(['mykey']);
FRedis.GET('mykey', lValue);
lOtherClient.&SET('mykey', '1111'); // this invalidate the transaction
FRedis.MULTI;
CheckTrue(FRedis.InTransaction, 'Is not in transaction when it should');
FRedis.&SET('mykey', IntToStr(StrToInt(lValue) + 1));
try
FRedis.EXEC;
fail('No exception efter EXEC');
except
on E: Exception do
begin
CheckInherits(ERedisException, E.ClassType);
end;
end;
CheckFalse(FRedis.InTransaction, 'Is in transaction when it should not');
end;
procedure TestRedisClient.TestWATCH_OK;
var
lValue: string;
lOtherClient: IRedisClient;
begin
lOtherClient := NewRedisClient;
FRedis.&SET('mykey', '1234');
FRedis.WATCH(['mykey']);
FRedis.GET('mykey', lValue);
FRedis.MULTI(
procedure(const R: IRedisClient)
begin
R.&SET('mykey', IntToStr(StrToInt(lValue) + 1));
end);
end;
procedure TestRedisClient.TestZADD_ZRANK_ZCARD;
var
lValue: Int64;
begin
FRedis.DEL(['myset']);
FRedis.ZADD('myset', 1, 'one');
FRedis.ZADD('myset', 2, 'two');
FRedis.ZADD('myset', 3, 'three');
FRedis.ZADD('myset', 4, 'four');
FRedis.ZADD('myset', 5, 'five');
CheckEquals(5, FRedis.ZCARD('myset'));
CheckEquals(0, FRedis.ZCARD('notexists'));
CheckFalse(FRedis.ZRANK('myset', 'notexists', lValue));
CheckTrue(FRedis.ZRANK('myset', 'one', lValue));
CheckEquals(0, lValue);
CheckTrue(FRedis.ZRANK('myset', 'two', lValue));
CheckEquals(1, lValue);
CheckTrue(FRedis.ZRANK('myset', 'three', lValue));
CheckEquals(2, lValue);
CheckTrue(FRedis.ZRANK('myset', 'four', lValue));
CheckEquals(3, lValue);
CheckTrue(FRedis.ZRANK('myset', 'five', lValue));
CheckEquals(4, lValue);
end;
// procedure TestRedisClient.TestSUBSCRIBE;
// var
// Rcv: NativeInt;
// MSG: string;
// X: NativeInt;
// begin
// //not implemented
// {
// AtomicExchange(Rcv, 0);
// // It's used for immediate real-time messaging, not for history storage
// FRedis.SUBSCRIBE(['ch1', 'ch2'],
// procedure(Channel, Message: string)
// begin
// MSG := message;
// AtomicIncrement(Rcv, 1);
// end);
// }
// {
// while true do
// begin
// X := AtomicCmpExchange(Rcv, -1, -1);
// TThread.Sleep(100)
// end;
// CheckEquals('hello', MSG);
// }
// end;
initialization
// Register any test cases with the test runner
RegisterTest(TestRedisClient.Suite);
end.
|
unit uContainerDefault;
interface
uses
System.TypInfo,
System.SysUtils,
System.Generics.Collections;
type
TGetter = TFunc<IInterface>;
TContainer = class
strict private
FRegistros: TDictionary<PTypeInfo, TGetter>;
class var FDefault: TContainer;
class function GetDefault: TContainer; static;
public
class constructor Create;
class destructor Destroy;
constructor Create;
destructor Destroy; override;
procedure Registrar<I: IInterface>(const pGetter: TGetter);
function Get<I: IInterface>: I;
class property Default: TContainer read GetDefault;
end;
implementation
{ TContainer }
constructor TContainer.Create;
begin
FRegistros := TDictionary<PTypeInfo, TGetter>.Create;
end;
class constructor TContainer.Create;
begin
FDefault := TContainer.Create;
end;
destructor TContainer.Destroy;
begin
FRegistros.Free;
inherited;
end;
class destructor TContainer.Destroy;
begin
FDefault.Free;
end;
function TContainer.Get<I>: I;
var
lTipo: PTypeInfo;
lGetter: TGetter;
lInterfaceGerada: IInterface;
begin
lTipo := TypeInfo(I);
lGetter := FRegistros.Items[lTipo];
lInterfaceGerada := lGetter();
if not Supports(lInterfaceGerada, lTipo^.TypeData^.GUID, Result) then
raise Exception.Create('Opa, algum registro foi mal feito!');
end;
class function TContainer.GetDefault: TContainer;
begin
Result := FDefault;
end;
procedure TContainer.Registrar<I>(const pGetter: TGetter);
begin
FRegistros.Add(TypeInfo(I), pGetter);
end;
end.
|
unit UserListDlg;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, DB, DBClient, ZjhCtrls, Grids, DBGrids, StdCtrls, Buttons;
type
TDlgUserList = class(TForm)
DBGrid1: TDBGrid;
cdsUser: TZjhDataSet;
dsUser: TDataSource;
cdsUserCode_: TStringField;
cdsUserName_: TStringField;
cdsUserPassword_: TStringField;
cdsUserLevel_: TIntegerField;
cdsUserRemark_: TStringField;
BitBtn3: TBitBtn;
BitBtn4: TBitBtn;
procedure FormCreate(Sender: TObject);
procedure cdsUserNewRecord(DataSet: TDataSet);
procedure cdsUserLevel_GetText(Sender: TField; var Text: String;
DisplayText: Boolean);
procedure cdsUserLevel_SetText(Sender: TField; const Text: String);
private
{ Private declarations }
slLevel: TStrings;
public
{ Public declarations }
end;
implementation
{$R *.dfm}
procedure TDlgUserList.FormCreate(Sender: TObject);
var
i: Integer;
begin
slLevel := nil;
cdsUser.CreateDataSet;
with DBGrid1 do
begin
for i := 0 to Columns.Count - 1 do
begin
if Columns[i].Field = cdsUser.FieldByName('Level_') then
begin
Columns[i].PickList.Add('0.¹ÜÀíÔ±');
Columns[i].PickList.Add('1.¶Áд');
Columns[i].PickList.Add('2.Ö»¶Á');
slLevel := Columns[i].PickList;
end;
end;
end;
end;
procedure TDlgUserList.cdsUserNewRecord(DataSet: TDataSet);
begin
with DataSet do
begin
FieldByName('Level_').AsInteger := 0;
end;
end;
procedure TDlgUserList.cdsUserLevel_GetText(Sender: TField;
var Text: String; DisplayText: Boolean);
begin
if not Assigned(slLevel) then Exit;
if cdsUser.RecordCount < 1 then Exit;
Text := slLevel.Strings[Sender.AsInteger];
end;
procedure TDlgUserList.cdsUserLevel_SetText(Sender: TField;
const Text: String);
begin
if not Assigned(slLevel) then Exit;
if slLevel.IndexOf(Text) > -1 then
Sender.AsInteger := slLevel.IndexOf(Text)
else
Sender.AsInteger := 0;
end;
end.
|
unit ThreeDSFile;
interface
uses BasicDataTypes, BasicFunctions;
const
C_MAIN_CHUNK = $4D4D;
C_3DEDITOR_CHUNK = $3D3D;
C_OBJECT_BLOCK = $4000;
C_TRIANGULAR_MESH = $4100;
C_VERTICES_LIST = $4110;
C_FACES_DESCRIPTION = $4120;
C_FACES_MATERIAL = $4130;
C_MAPPING_COORDINATES_LIST = $4140;
C_SMOOTHING_GROUP_LIST = $4150;
C_LOCAL_COORDINATES_SYSTEM = $4160;
C_LIGHT = $4600;
C_SPOTLIGHT = $4610;
C_CAMERA = $4700;
C_MATERIAL_BLOCK = $AFFF;
C_MATERIAL_NAME = $A000;
C_AMBIENT_COLOR = $A010;
C_DIFFUSE_COLOR = $A020;
C_SPECULAR_COLOR = $A030;
C_TEXTURE_MAP = $A200;
C_BUMP_MAP = $A230;
C_REFLECTION_MAP = $A220;
C_MAPPING_FILENAME = $A300;
C_MAPPING_PARAMETERS = $A351;
C_KEYFRAMER_CHUNK = $B000;
C_MESH_INFORMATION_BLOCK = $B002;
C_SPOT_LIGHT_INFORMATION_BLOCK = $B007;
C_FRAMES = $B008;
C_OBJECT_NAME = $B010;
C_OBJECT_PIVOT_POINT = $B013;
C_POSITION_TRACK = $B020;
C_ROTATION_TRACK = $B021;
C_SCALE_TRACK = $B022;
C_HIERARCHY_POSITION = $B030;
type
T3DSFile = class
private
public
// Constructors and Destructors
constructor Create;
destructor Destroy; override;
// I/O
end;
implementation
constructor T3DSFile.Create;
begin
// Do nothing
end;
destructor T3DSFile.Destroy;
begin
inherited Destroy;
end;
end.
|
unit uSubSaleConsult;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uParentSub, siComp, siLangRT, ExtCtrls, Grids, DBGrids,
SMDBGrid, DB, ADODB, StdCtrls, Mask, DateBox, Buttons, LblEffct,
cxStyles, cxCustomData, cxGraphics, cxFilter, cxData, cxEdit, cxDBData,
cxGridCustomTableView, cxGridTableView, cxGridDBTableView, cxGridLevel,
cxClasses, cxControls, cxGridCustomView, cxGrid;
type
TSubSaleConsult = class(TParentSub)
quPreSale: TADOQuery;
quPreSaleIDPreSale: TIntegerField;
quPreSalePreSaleDate: TDateTimeField;
dsPreSale: TDataSource;
pnlFilter: TPanel;
dtCustFileDate: TDateBox;
cbSearchFor: TComboBox;
edtParamText: TEdit;
edtHold: TEdit;
quPreSalePessoaLastName: TStringField;
quPreSalePessoaFirstName: TStringField;
quPreSaleIDTouristGroup: TIntegerField;
quPreSaleOtherComissionID: TIntegerField;
Label4: TLabel;
Label1: TLabel;
Label3: TLabel;
lbParamSearch: TLabel;
cbSearchForName: TComboBox;
edtNameSearch: TEdit;
Label5: TLabel;
lbSearchName: TLabel;
quPreSalePessoa: TStringField;
Panel2: TPanel;
imgTopIni: TImage;
lblBasicFilter: TLabel;
Image1: TImage;
lblSubMenu: TLabelEffect;
Image3: TImage;
EspacamentoSuperior: TPanel;
EEE: TPanel;
pnlAviso: TPanel;
btnExec: TSpeedButton;
TimeAviso: TTimer;
quPreSaleSaleCode: TStringField;
grdBrowse: TcxGrid;
grdBrowseDB: TcxGridDBTableView;
grdBrowseLevel: TcxGridLevel;
grdBrowseDBPreSaleDate: TcxGridDBColumn;
grdBrowseDBTotInvoice: TcxGridDBColumn;
grdBrowseDBPessoaFirstName: TcxGridDBColumn;
grdBrowseDBPessoaLastName: TcxGridDBColumn;
grdBrowseDBSaleCode: TcxGridDBColumn;
cbxHoldStatus: TComboBox;
lbStatus: TLabel;
quPreSaleTotalInvoice: TBCDField;
quPreSaleTotalParent: TBCDField;
quPreSaleTotInvoice: TCurrencyField;
quPreSaleSubTotalInvoice: TBCDField;
quPreSaleSubTotalParent: TBCDField;
grdBrowseDBCustomer: TcxGridDBColumn;
btnShowNote: TButton;
quPreSaleNote: TStringField;
grdBrowseDBNote: TcxGridDBColumn;
procedure cbSearchForChange(Sender: TObject);
procedure edtParamTextChange(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure grdPreSalesDblClick(Sender: TObject);
procedure cbSearchForNameChange(Sender: TObject);
procedure TimeAvisoTimer(Sender: TObject);
procedure btnExecClick(Sender: TObject);
procedure cbxHoldStatusChange(Sender: TObject);
procedure quPreSaleCalcFields(DataSet: TDataSet);
procedure btnShowNoteClick(Sender: TObject);
private
FIsClosedLayAway: Boolean;
procedure SearchCustomer;
procedure RefreshDataSet;
procedure AfterSetParam;override;
{ Private declarations }
public
procedure DataSetOpen; override;
procedure DataSetClose; override;
function GiveInfo(InfoString: String): String;override;
procedure SubListrefresh;override;
{ Public declarations }
end;
var
SubSaleConsult: TSubSaleConsult;
implementation
uses uDM, uParamFunctions, uDateTimeFunctions;
{$R *.dfm}
procedure TSubSaleConsult.SearchCustomer;
var
sField, sWhere : String;
begin
quPreSale.Close;
TimeAviso.Enabled := False;
pnlAviso.ParentColor := True;
sWhere := '';
quPreSale.SQL.Clear;
quPreSale.SQL.Add('');
quPreSale.SQL.Add('SELECT');
quPreSale.SQL.Add(' I.IDPreSale,');
quPreSale.SQL.Add(' I.SaleCode,');
quPreSale.SQL.Add(' I.PreSaleDate,');
quPreSale.SQL.Add(' I.Note,');
quPreSale.SQL.Add(' P.PessoaFirstName,');
quPreSale.SQL.Add(' P.PessoaLastName,');
quPreSale.SQL.Add(' P.Pessoa,');
quPreSale.SQL.Add(' (I.SubTotal - I.InvoiceDiscount - I.ItemDiscount + I.Tax + IsNull(I.AditionalExpenses, 0)) as TotalInvoice,');
quPreSale.SQL.Add(' (I.SubTotal - I.InvoiceDiscount - I.ItemDiscount + I.Tax) as SubTotalInvoice,');
if not FIsClosedLayAway then
begin
quPreSale.SQL.Add(' .00 as TotalParent,');
quPreSale.SQL.Add(' .00 as SubTotalParent,');
end
else
begin
quPreSale.SQL.Add(' (SELECT SUM(IP.SubTotal - IP.InvoiceDiscount - IP.ItemDiscount + IP.Tax + IsNull(IP.AditionalExpenses, 0))');
quPreSale.SQL.Add(' FROM Invoice IP WHERE IP.IDPreSaleParent = I.IDPreSale) as TotalParent,');
quPreSale.SQL.Add(' (SELECT SUM(IP.SubTotal - IP.InvoiceDiscount - IP.ItemDiscount + IP.Tax)');
quPreSale.SQL.Add(' FROM Invoice IP WHERE IP.IDPreSaleParent = I.IDPreSale) as SubTotalParent,');
end;
quPreSale.SQL.Add(' I.IDTouristGroup,');
quPreSale.SQL.Add(' I.OtherComissionID');
quPreSale.SQL.Add('FROM');
quPreSale.SQL.Add(' Invoice I (NOLOCK)');
quPreSale.SQL.Add(' INNER JOIN Pessoa P (NOLOCK) ON I.IDCustomer = P.IDPessoa');
quPreSale.SQL.Add(' LEFT OUTER JOIN DeliverType DT ON (DT.IDDeliverType = I.DeliverTypeID)');
quPreSale.SQL.Add('WHERE');
quPreSale.SQL.Add(' I.Layaway = 1');
quPreSale.SQL.Add(' AND I.Canceled = 0');
quPreSale.SQL.Add(' AND I.IDInvoice Is Null');
if FIsClosedLayAway then
begin
quPreSale.SQL.Add(' AND I.DeliverConfirmation = 1');
quPreSale.SQL.Add(' AND I.DeliverDate <= Convert(DateTime, Convert(varchar, GetDate()+1, 103), 103)');
end
else
begin
quPreSale.SQL.Add(' AND I.IDPreSaleParent Is Null');
end;
if cbSearchFor.Itemindex > 0 then
begin
case cbSearchFor.Itemindex of
1 : sField := 'P.CustomerCard';
2 : sField := 'P.CPF';
3 : sField := 'P.InscEstadual';
4 : sField := 'P.CartTrabalho';
end;
sWhere := sWhere + ' AND ' + sField + ' Like ' + QuotedStr('%'+Trim(edtParamText.Text)+'%');
end;
if cbSearchForName.Itemindex > 0 then
begin
case cbSearchForName.Itemindex of
1 : sField := 'P.PessoaFirstName';
2 : sField := 'P.PessoaLastName';
3 : sField := 'P.Pessoa';
end;
sWhere := sWhere + ' AND ' + sField + ' Like ' + QuotedStr('%'+Trim(edtNameSearch.Text)+'%');
end;
if Trim(edtHold.Text) <> '' then
sWhere := sWhere + ' AND SaleCode Like ' + QuotedStr('%'+Trim(edtHold.Text)+'%');
if Trim(dtCustFileDate.Text) <> '' then
sWhere := sWhere + Format(' AND Convert(DateTime, Convert(VarChar, PreSaleDate, 103), 103) = Convert(DateTime, %S, 103)', [QuotedStr(FormatdateTime('DD/MM/YYYY', dtCustFileDate.Date))]);
//Mostrar itens abertos e cancelados
if FIsClosedLayAway then
Case cbxHoldStatus.ItemIndex of
1 : sWhere := sWhere + 'AND IsNull(DT.CanExchangeItem,0) <> 1';
2 : sWhere := sWhere + 'AND IsNull(DT.CanExchangeItem,0) = 1';
end;
quPreSale.SQL.Add(sWhere);
quPreSale.Open;
end;
procedure TSubSaleConsult.cbSearchForChange(Sender: TObject);
begin
inherited;
lbParamSearch.Caption := cbSearchFor.Items[cbSearchFor.Itemindex];
TimeAviso.Enabled := True;
end;
procedure TSubSaleConsult.edtParamTextChange(Sender: TObject);
begin
TimeAviso.Enabled := True;
end;
procedure TSubSaleConsult.DataSetClose;
begin
if quPreSale.Active Then
quPreSale.Close;
end;
procedure TSubSaleConsult.DataSetOpen;
begin
SearchCustomer;
end;
procedure TSubSaleConsult.FormDestroy(Sender: TObject);
begin
inherited;
DataSetClose;
end;
procedure TSubSaleConsult.FormShow(Sender: TObject);
begin
inherited;
SearchCustomer;
end;
procedure TSubSaleConsult.grdPreSalesDblClick(Sender: TObject);
begin
inherited;
NotifyChanges(Format('IDPRESALE=%D;IDTOURISTGROUP=%D;OTHERCOMISSIONID=%D;',
[quPreSaleIDPreSale.AsInteger,
quPreSaleIDTouristGroup.AsInteger,
quPreSaleOtherComissionID.AsInteger]));
end;
function TSubSaleConsult.GiveInfo(InfoString: String): String;
begin
Result :=
Format('IDPRESALE=%D;IDTOURISTGROUP=%D;OTHERCOMISSIONID=%D;ISEMPTY=%D;SALECODE=%S;TOTALINVOICE=%F',
[quPreSaleIDPreSale.AsInteger,
quPreSaleIDTouristGroup.AsInteger,
quPreSaleOtherComissionID.AsInteger,
Byte(quPreSale.IsEmpty),
quPreSaleSaleCode.AsString,
quPreSaleSubTotalInvoice.AsCurrency]);
end;
procedure TSubSaleConsult.RefreshDataSet;
begin
DataSetClose;
DataSetOpen;
end;
procedure TSubSaleConsult.SubListrefresh;
begin
inherited;
RefreshDataSet;
end;
procedure TSubSaleConsult.AfterSetParam;
begin
if Param = '' then Exit;
FIsClosedLayAway := ParseParam(Param, 'ISCLOSEDLAYAWAY') = '1';
lbStatus.Visible := FIsClosedLayAway;
cbxHoldStatus.Visible := lbStatus.Visible;
RefreshDataSet;
end;
procedure TSubSaleConsult.cbSearchForNameChange(Sender: TObject);
begin
inherited;
lbSearchName.Caption := cbSearchForName.Items[cbSearchForName.Itemindex];
TimeAviso.Enabled := True;
end;
procedure TSubSaleConsult.TimeAvisoTimer(Sender: TObject);
begin
inherited;
if pnlAviso.ParentColor = True then
pnlAviso.Color := clNavy
else
pnlAviso.ParentColor := True;
end;
procedure TSubSaleConsult.btnExecClick(Sender: TObject);
begin
inherited;
SearchCustomer;
end;
procedure TSubSaleConsult.cbxHoldStatusChange(Sender: TObject);
begin
inherited;
TimeAviso.Enabled := True;
end;
procedure TSubSaleConsult.quPreSaleCalcFields(DataSet: TDataSet);
begin
inherited;
if not FIsClosedLayAway then
quPreSaleTotInvoice.AsCurrency := quPreSaleTotalInvoice.AsCurrency
else
quPreSaleTotInvoice.AsCurrency := (quPreSaleSubTotalInvoice.AsCurrency-
quPreSaleSubTotalParent.AsCurrency);
end;
procedure TSubSaleConsult.btnShowNoteClick(Sender: TObject);
begin
inherited;
grdBrowseDB.Preview.Visible := not grdBrowseDB.Preview.Visible;
end;
initialization
RegisterClass(TSubSaleConsult);
end.
|
// ----------- Parse::Easy::Runtime -----------
// https://github.com/MahdiSafsafi/Parse-Easy
// --------------------------------------------
unit Parse.Easy.Lexer.CustomLexer;
interface
uses
System.SysUtils,
System.Types,
System.Classes,
System.ZLib,
Vcl.Dialogs,
Parse.Easy.Lexer.CodePointStream,
Parse.Easy.Lexer.VirtualMachine,
Parse.Easy.Lexer.Token;
type
TCustomLexer = class(TVirtualMachine)
private
FToken: TToken;
public
constructor Create(AStream: TStringStream); override;
destructor Destroy(); override;
function Peek(): TToken;
function Advance(): TToken;
function GetTokenName(Index: Integer): string; virtual; abstract;
end;
implementation
{ TCustomLexer }
constructor TCustomLexer.Create(AStream: TStringStream);
begin
inherited;
FToken := nil;
end;
destructor TCustomLexer.Destroy();
begin
inherited;
end;
function TCustomLexer.Advance(): TToken;
begin
Result := FToken;
FToken := Parse();
end;
function TCustomLexer.Peek: TToken;
begin
if not Assigned(FToken) then
Advance();
Result := FToken;
end;
end.
|
unit fillables;
interface
type
TFillableSingle = record
IsFilled: boolean;
Value: single;
function ToString: string;
end;
TFillableDateTime = record
IsFilled: boolean;
Value: TDateTime;
function ToString: string;
end;
implementation
uses
System.SysUtils;
{ TFillableSingle }
function TFillableSingle.ToString: string;
begin
if IsFilled then
Result := FloatToStr(Value)
else
Result := '';
end;
{ TFillableDateTime }
function TFillableDateTime.ToString: string;
begin
if IsFilled then
Result := DateTimeToStr(Value)
else
Result := '';
end;
end.
|
//---------------------------------------------------------------------------
// This software is Copyright (c) 2011 Embarcadero Technologies, Inc.
// You may only use this software if you are an authorized licensee
// of Delphi, C++Builder or RAD Studio (Embarcadero Products).
// This software is considered a Redistributable as defined under
// the software license agreement that comes with the Embarcadero Products
// and is subject to that software license agreement.
//---------------------------------------------------------------------------
unit AddFilesFrameUnit;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes,
Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ActnList,
Vcl.StdActns, Vcl.StdCtrls;
type
TAddFilesFrame = class(TFrame)
Label1: TLabel;
Button1: TButton;
ActionList1: TActionList;
FileOpen1: TFileOpen;
Memo1: TMemo;
procedure FileOpen1Accept(Sender: TObject);
procedure Edit1Change(Sender: TObject);
procedure Memo1Change(Sender: TObject);
private
FFileNames: TArray<string>;
FUpdateNeeded: Boolean;
function GetFileNames: TArray<string>;
procedure UpdateFileNames;
{ Private declarations }
public
{ Public declarations }
procedure Validate;
property FileNames: TArray<string> read GetFileNames;
end;
implementation
{$R *.dfm}
procedure TAddFilesFrame.Edit1Change(Sender: TObject);
begin
FUpdateNeeded := True;
end;
procedure TAddFilesFrame.FileOpen1Accept(Sender: TObject);
begin
if Memo1.Text <> '' then
Memo1.Text := Memo1.Text + '; ';
Memo1.Text := Memo1.Text + FileOpen1.Dialog.FileName;
end;
function TAddFilesFrame.GetFileNames: TArray<string>;
begin
UpdateFileNames;
Result := FFileNames;
end;
procedure TAddFilesFrame.Memo1Change(Sender: TObject);
begin
FUpdateNeeded := True;
end;
procedure TAddFilesFrame.UpdateFileNames;
var
LStrings: TStrings;
begin
if FUpdateNeeded then
begin
FUpdateNeeded := False;
LStrings := TStringList.Create;
try
LStrings.Delimiter := ';';
LStrings.DelimitedText := Memo1.Text;
FFileNames := LStrings.ToStringArray;
finally
LStrings.Free;
end;
end;
end;
procedure TAddFilesFrame.Validate;
var
S: string;
begin
for S in FileNames do
if not FileExists(S) then
raise Exception.CreateFmt('File not found: "%s"', [S]);
end;
end.
|
unit parserTree;
{$mode objfpc}{$H+}
interface
uses
Classes, PasTree, PParser;
type
{ TWraperTreeContainer }
TWraperTreeContainer = class(TPasTreeContainer)
private
fElements : TStringList;
function GetCount: Integer;
function GetItem(index: integer): TPasElement;
public
constructor Create;
destructor Destroy; override;
procedure DumpToFile(FileName : AnsiString);
procedure Clear;
function CreateElement(AClass: TPTreeElement; const AName: String;
AParent: TPasElement; AVisibility: TPasMemberVisibility;
const ASourceFilename: String; ASourceLinenumber: Integer): TPasElement;
override;
function FindElement(const AName: String): TPasElement; override;
property Count : Integer read GetCount;
property Item[index:integer] : TPasElement read GetItem;
end;
implementation
function TWraperTreeContainer.GetCount: Integer;
begin
result := fElements.Count;
end;
function TWraperTreeContainer.GetItem(index: integer): TPasElement;
begin
result := TPasElement(fElements.Objects[index]);
end;
constructor TWraperTreeContainer.Create;
begin
fElements := TStringList.Create;
end;
destructor TWraperTreeContainer.Destroy;
begin
fElements.Free;
inherited Destroy;
end;
procedure TWraperTreeContainer.Clear;
begin
fElements.Clear;
end;
function TWraperTreeContainer.CreateElement(AClass: TPTreeElement; const AName: String;
AParent: TPasElement; AVisibility: TPasMemberVisibility;
const ASourceFilename: String; ASourceLinenumber: Integer): TPasElement;
begin
result := AClass.Create(AName, AParent);
result.Visibility := AVisibility;
result.SourceFilename := ASourceFilename;
result.SourceLinenumber := ASourceLinenumber;
fElements.AddObject(AName, result);
end;
function TWraperTreeContainer.FindElement(const AName: String): TPasElement;
var
idx : Integer;
begin
idx := fElements.IndexOf(AName);
if idx > -1 then
result := TPasElement(fElements.Objects[idx])
else
result := nil;
end;
procedure TWraperTreeContainer.DumpToFile(FileName : AnsiString);
begin
fElements.SaveToFile(FileName);
end;
end.
|
unit Chapter05._05_Solution1;
{$mode objfpc}{$H+}
interface
uses
Classes,
SysUtils,
AI.ListNode,
DeepStar.Utils;
// 237. Delete Node in a Linked List
// https://leetcode.com/problems/delete-node-in-a-linked-list/description/
// 时间复杂度: O(1)
// 空间复杂度: O(1)
type
TSolution = class(TObject)
public
procedure deleteNode(node: TListNode);
end;
procedure Main;
implementation
procedure Main;
var
a: TArr_int;
head, del: TListNode;
begin
a := [1, 2, 3, 4];
head := TListNode.Create(a);
with TSolution.Create do
begin
del := head.FindNdoe(2);
deleteNode(del);
WriteLn(head.ToString);
Free;
end;
head.CLearAndFree;
end;
{ TSolution }
procedure TSolution.deleteNode(node: TListNode);
var
cur, del: TListNode;
begin
if (node = nil) or (node.Next = nil) then Exit;
cur := node;
del := cur.Next;
cur.Val := del.Val;
cur.Next := del.Next;
FreeAndNil(del);
end;
end.
|
{*******************************************************************************
Title: T2Ti ERP
Description: Controller do lado Cliente relacionado à tabela [OS_ABERTURA]
The MIT License
Copyright: Copyright (C) 2016 T2Ti.COM
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
The author may be contacted at:
t2ti.com@gmail.com
@author Albert Eije (t2ti.com@gmail.com)
@version 2.0
*******************************************************************************}
unit OsAberturaController;
interface
uses
Classes, Dialogs, SysUtils, DB, LCLIntf, LCLType, LMessages, Forms, Controller,
VO, ZDataset, OsAberturaVO;
type
TOsAberturaController = class(TController)
private
public
class function Consulta(pFiltro: String; pPagina: String): TZQuery;
class function ConsultaLista(pFiltro: String): TListaOsAberturaVO;
class function ConsultaObjeto(pFiltro: String): TOsAberturaVO;
class procedure Insere(pObjeto: TOsAberturaVO);
class function Altera(pObjeto: TOsAberturaVO): Boolean;
class function Exclui(pId: Integer): Boolean;
end;
implementation
uses UDataModule, T2TiORM, OsProdutoServicoVO, OsAberturaEquipamentoVO, OsEvolucaoVO;
var
ObjetoLocal: TOsAberturaVO;
class function TOsAberturaController.Consulta(pFiltro: String; pPagina: String): TZQuery;
begin
try
ObjetoLocal := TOsAberturaVO.Create;
Result := TT2TiORM.Consultar(ObjetoLocal, pFiltro, pPagina);
finally
ObjetoLocal.Free;
end;
end;
class function TOsAberturaController.ConsultaLista(pFiltro: String): TListaOsAberturaVO;
begin
try
ObjetoLocal := TOsAberturaVO.Create;
Result := TListaOsAberturaVO(TT2TiORM.Consultar(ObjetoLocal, pFiltro, True));
finally
ObjetoLocal.Free;
end;
end;
class function TOsAberturaController.ConsultaObjeto(pFiltro: String): TOsAberturaVO;
begin
try
Result := TOsAberturaVO.Create;
Result := TOsAberturaVO(TT2TiORM.ConsultarUmObjeto(Result, pFiltro, True));
finally
end;
end;
class procedure TOsAberturaController.Insere(pObjeto: TOsAberturaVO);
var
UltimoID: Integer;
ProdutoServicoVO: TOsProdutoServicoVO;
EquipamentoVO: TOsAberturaEquipamentoVO;
EvolucaoVO: TOsEvolucaoVO;
begin
try
UltimoID := TT2TiORM.Inserir(pObjeto);
// Produtos
ProdutoServicoEnumerator := pObjeto.ListaOsProdutoServicoVO.GetEnumerator;
try
with ProdutoServicoEnumerator do
begin
while MoveNext do
begin
ProdutoServicoVO := Current;
ProdutoServicoVO.IdOsAbertura := UltimoID;
TT2TiORM.Inserir(ProdutoServicoVO);
end;
end;
finally
ProdutoServicoEnumerator.Free;
end;
// Equipamentos
EquipamentoEnumerator := pObjeto.ListaOsEquipamentoVO.GetEnumerator;
try
with EquipamentoEnumerator do
begin
while MoveNext do
begin
EquipamentoVO := Current;
EquipamentoVO.IdOsAbertura := UltimoID;
TT2TiORM.Inserir(EquipamentoVO);
end;
end;
finally
EquipamentoEnumerator.Free;
end;
// Evoluções
EvolucaoEnumerator := pObjeto.ListaOsEvolucaoVO.GetEnumerator;
try
with EvolucaoEnumerator do
begin
while MoveNext do
begin
EvolucaoVO := Current;
EvolucaoVO.IdOsAbertura := UltimoID;
TT2TiORM.Inserir(EvolucaoVO);
end;
end;
finally
EvolucaoEnumerator.Free;
end;
Consulta('ID = ' + IntToStr(UltimoID), '0');
finally
end;
end;
class function TOsAberturaController.Altera(pObjeto: TOsAberturaVO): Boolean;
var
begin
try
Result := TT2TiORM.Alterar(pObjeto);
// Produtos
try
ProdutoServicoEnumerator := pObjeto.ListaOsProdutoServicoVO.GetEnumerator;
with ProdutoServicoEnumerator do
begin
while MoveNext do
begin
if Current.Id > 0 then
Result := TT2TiORM.Alterar(Current)
else
begin
Current.IdOsAbertura := pObjeto.Id;
Result := TT2TiORM.Inserir(Current) > 0;
end;
end;
end;
finally
ProdutoServicoEnumerator.Free;
end;
// Equipamentos
EquipamentoEnumerator := pObjeto.ListaOsEquipamentoVO.GetEnumerator;
try
with EquipamentoEnumerator do
begin
while MoveNext do
begin
if Current.Id > 0 then
Result := TT2TiORM.Alterar(Current)
else
begin
Current.IdOsAbertura := pObjeto.Id;
Result := TT2TiORM.Inserir(Current) > 0;
end;
end;
end;
finally
EquipamentoEnumerator.Free;
end;
// Evoluções
EvolucaoEnumerator := pObjeto.ListaOsEvolucaoVO.GetEnumerator;
try
with EvolucaoEnumerator do
begin
while MoveNext do
begin
if Current.Id > 0 then
Result := TT2TiORM.Alterar(Current)
else
begin
Current.IdOsAbertura := pObjeto.Id;
Result := TT2TiORM.Inserir(Current) > 0;
end;
end;
end;
finally
EvolucaoEnumerator.Free;
end;
finally
end;
end;
class function TOsAberturaController.Exclui(pId: Integer): Boolean;
var
ObjetoLocal: TOsAberturaVO;
begin
try
ObjetoLocal := TOsAberturaVO.Create;
ObjetoLocal.Id := pId;
Result := TT2TiORM.Excluir(ObjetoLocal);
finally
FreeAndNil(ObjetoLocal)
end;
end;
begin
Result := FDataSet;
end;
begin
FDataSet := pDataSet;
end;
begin
try
finally
FreeAndNil(pListaObjetos);
end;
end;
initialization
Classes.RegisterClass(TOsAberturaController);
finalization
Classes.UnRegisterClass(TOsAberturaController);
end.
|
//*****************************************************************************************************\\
// Copyright (©) Cergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
// This code is distributed under the Unlicense
// For details see LICENSE file or this:
// https://github.com/SunSerega/POCGL/blob/master/LICENSE
//*****************************************************************************************************\\
// Copyright (©) Сергей Латченко ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
// Этот код распространяется с лицензией Unlicense
// Подробнее в файле LICENSE или тут:
// https://github.com/SunSerega/POCGL/blob/master/LICENSE
//*****************************************************************************************************\\
///
///Код переведён отсюда:
/// https://github.com/KhronosGroup/OpenGL-Registry/tree/master/xml
///
///Спецификации всех версий OpenGL:
/// https://www.khronos.org/registry/OpenGL/specs/gl/
///
///Если чего-либо не хватает, или найдена ошибка - писать сюда:
/// https://github.com/SunSerega/POCGL/issues
///
unit OpenGL;
interface
uses System;
uses System.Runtime.InteropServices;
uses System.Runtime.CompilerServices;
{$region Основные типы} type
DummyEnum = UInt32;
DummyFlags = UInt32;
OpenGLException = class(Exception)
constructor(text: string) :=
inherited Create($'Ошибка OpenGL: "{text}"');
end;
{$endregion Основные типы}
{$region Записи-имена} type
GLsync = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLsync read default(GLsync);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLeglImageOES = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLeglImageOES read default(GLeglImageOES);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
QueryName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: QueryName read default(QueryName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
BufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: BufferName read default(BufferName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
ShaderName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ShaderName read default(ShaderName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
ProgramName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramName read default(ProgramName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
ProgramPipelineName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramPipelineName read default(ProgramPipelineName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
TextureName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: TextureName read default(TextureName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
SamplerName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: SamplerName read default(SamplerName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
FramebufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: FramebufferName read default(FramebufferName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
RenderbufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: RenderbufferName read default(RenderbufferName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
VertexArrayName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: VertexArrayName read default(VertexArrayName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
TransformFeedbackName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: TransformFeedbackName read default(TransformFeedbackName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
GLContext = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLContext read default(GLContext);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
GDI_DC = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_DC read default(GDI_DC);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
// типы для совместимости с OpenCL
///--
cl_context = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: cl_context read default(cl_context);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
///--
cl_event = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: cl_event read default(cl_event);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
// INTEL_performance_query
PerfQueryIdINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PerfQueryIdINTEL read default(PerfQueryIdINTEL);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
PerfQueryHandleINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PerfQueryHandleINTEL read default(PerfQueryHandleINTEL);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
//ToDo переименовать и проверить типы всего дальше:
EGLsync = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: EGLsync read default(EGLsync);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
EGLDisplay = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: EGLDisplay read default(EGLDisplay);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
ShaderBinaryFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ShaderBinaryFormat read default(ShaderBinaryFormat);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
ProgramResourceIndex = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramResourceIndex read default(ProgramResourceIndex);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
ProgramBinaryFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramBinaryFormat read default(ProgramBinaryFormat);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
GLhandleARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLhandleARB read default(GLhandleARB);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
PBufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PBufferName read default(PBufferName);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
HPVIDEODEV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HPVIDEODEV read default(HPVIDEODEV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
HVIDEOOUTPUTDEVICENV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HVIDEOOUTPUTDEVICENV read default(HVIDEOOUTPUTDEVICENV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
HVIDEOINPUTDEVICENV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HVIDEOINPUTDEVICENV read default(HVIDEOINPUTDEVICENV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
PGPU_DEVICE = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PGPU_DEVICE read default(PGPU_DEVICE);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
HGPUNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HGPUNV read default(HGPUNV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
HPBUFFER = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HPBUFFER read default(HPBUFFER);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLeglClientBufferEXT = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLeglClientBufferEXT read default(GLeglClientBufferEXT);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
VideoOutputDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoOutputDeviceHandleNV read default(VideoOutputDeviceHandleNV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
VideoInputDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoInputDeviceHandleNV read default(VideoInputDeviceHandleNV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
VideoDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoDeviceHandleNV read default(VideoDeviceHandleNV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLvdpauSurfaceNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLvdpauSurfaceNV read default(GLvdpauSurfaceNV);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GPUAffinityHandle = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GPUAffinityHandle read default(GPUAffinityHandle);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXFBConfig = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXFBConfig read default(GLXFBConfig);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXContextID = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXContextID read default(GLXContextID);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXPbuffer = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXPbuffer read default(GLXPbuffer);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXWindow = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXWindow read default(GLXWindow);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXPixmap = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXPixmap read default(GLXPixmap);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXColormap = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXColormap read default(GLXColormap);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXDrawable = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXDrawable read default(GLXDrawable);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXContext = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXContext read default(GLXContext);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXVideoCaptureDeviceNV = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXVideoCaptureDeviceNV read default(GLXVideoCaptureDeviceNV);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXVideoSourceSGIX = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXVideoSourceSGIX read default(GLXVideoSourceSGIX);
public static property Size: integer read Marshal.SizeOf&<UInt64>;
end;
GLXVideoDeviceNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLXVideoDeviceNV read default(GLXVideoDeviceNV);
public static property Size: integer read Marshal.SizeOf&<UInt32>;
end;
GLXFuncPtr = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXFuncPtr read default(GLXFuncPtr);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
PDisplay = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PDisplay read default(PDisplay);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
PXVisualInfo = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PXVisualInfo read default(PXVisualInfo);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
//ToDo эти типы вообще угадывал, перепроверить
GLXDMparams = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXDMparams read default(GLXDMparams);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXDMbuffer = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXDMbuffer read default(GLXDMbuffer);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXVLServer = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLServer read default(GLXVLServer);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXVLPath = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLPath read default(GLXVLPath);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXVLNode = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLNode read default(GLXVLNode);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLXStatus = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXStatus read default(GLXStatus);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GLUnurbs = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLUnurbs read default(GLUnurbs);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GDI_HENHMetafile = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_HENHMetafile read default(GDI_HENHMetafile);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
GDI_LayerPlaneDescriptor = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_LayerPlaneDescriptor read default(GDI_LayerPlaneDescriptor);
public static property Size: integer read Marshal.SizeOf&<IntPtr>;
end;
{$endregion Записи-имена}
{$region Перечисления} type
{$region Core}
AccumOp = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ACCUM := new AccumOp($0100);
private static _LOAD := new AccumOp($0101);
private static _RETURN := new AccumOp($0102);
private static _MULT := new AccumOp($0103);
private static _ADD := new AccumOp($0104);
public static property ACCUM: AccumOp read _ACCUM;
public static property LOAD: AccumOp read _LOAD;
public static property RETURN: AccumOp read _RETURN;
public static property MULT: AccumOp read _MULT;
public static property ADD: AccumOp read _ADD;
public function ToString: string; override;
begin
if self.val = UInt32($0100) then Result := 'ACCUM' else
if self.val = UInt32($0101) then Result := 'LOAD' else
if self.val = UInt32($0102) then Result := 'RETURN' else
if self.val = UInt32($0103) then Result := 'MULT' else
if self.val = UInt32($0104) then Result := 'ADD' else
Result := self.val.ToString;
end;
end;
AlphaFunction = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEVER := new AlphaFunction($0200);
private static _LESS := new AlphaFunction($0201);
private static _EQUAL := new AlphaFunction($0202);
private static _LEQUAL := new AlphaFunction($0203);
private static _GREATER := new AlphaFunction($0204);
private static _NOTEQUAL := new AlphaFunction($0205);
private static _GEQUAL := new AlphaFunction($0206);
private static _ALWAYS := new AlphaFunction($0207);
public static property NEVER: AlphaFunction read _NEVER;
public static property LESS: AlphaFunction read _LESS;
public static property EQUAL: AlphaFunction read _EQUAL;
public static property LEQUAL: AlphaFunction read _LEQUAL;
public static property GREATER: AlphaFunction read _GREATER;
public static property NOTEQUAL: AlphaFunction read _NOTEQUAL;
public static property GEQUAL: AlphaFunction read _GEQUAL;
public static property ALWAYS: AlphaFunction read _ALWAYS;
public function ToString: string; override;
begin
if self.val = UInt32($0200) then Result := 'NEVER' else
if self.val = UInt32($0201) then Result := 'LESS' else
if self.val = UInt32($0202) then Result := 'EQUAL' else
if self.val = UInt32($0203) then Result := 'LEQUAL' else
if self.val = UInt32($0204) then Result := 'GREATER' else
if self.val = UInt32($0205) then Result := 'NOTEQUAL' else
if self.val = UInt32($0206) then Result := 'GEQUAL' else
if self.val = UInt32($0207) then Result := 'ALWAYS' else
Result := self.val.ToString;
end;
end;
AtomicCounterBufferPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER := new AtomicCounterBufferPName($90ED);
private static _ATOMIC_COUNTER_BUFFER_BINDING := new AtomicCounterBufferPName($92C1);
private static _ATOMIC_COUNTER_BUFFER_DATA_SIZE := new AtomicCounterBufferPName($92C4);
private static _ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS := new AtomicCounterBufferPName($92C5);
private static _ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES := new AtomicCounterBufferPName($92C6);
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER := new AtomicCounterBufferPName($92C7);
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER := new AtomicCounterBufferPName($92C8);
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER := new AtomicCounterBufferPName($92C9);
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER := new AtomicCounterBufferPName($92CA);
private static _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER := new AtomicCounterBufferPName($92CB);
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER;
public static property ATOMIC_COUNTER_BUFFER_BINDING: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_BINDING;
public static property ATOMIC_COUNTER_BUFFER_DATA_SIZE: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_DATA_SIZE;
public static property ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS;
public static property ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES;
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER;
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER;
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER;
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER;
public static property ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER: AtomicCounterBufferPName read _ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER;
public function ToString: string; override;
begin
if self.val = UInt32($90ED) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER' else
if self.val = UInt32($92C1) then Result := 'ATOMIC_COUNTER_BUFFER_BINDING' else
if self.val = UInt32($92C4) then Result := 'ATOMIC_COUNTER_BUFFER_DATA_SIZE' else
if self.val = UInt32($92C5) then Result := 'ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS' else
if self.val = UInt32($92C6) then Result := 'ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES' else
if self.val = UInt32($92C7) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER' else
if self.val = UInt32($92C8) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER' else
if self.val = UInt32($92C9) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER' else
if self.val = UInt32($92CA) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER' else
if self.val = UInt32($92CB) then Result := 'ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER' else
Result := self.val.ToString;
end;
end;
AttribMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CURRENT_BIT := new AttribMask($0001);
private static _POINT_BIT := new AttribMask($0002);
private static _LINE_BIT := new AttribMask($0004);
private static _POLYGON_BIT := new AttribMask($0008);
private static _POLYGON_STIPPLE_BIT := new AttribMask($0010);
private static _PIXEL_MODE_BIT := new AttribMask($0020);
private static _LIGHTING_BIT := new AttribMask($0040);
private static _FOG_BIT := new AttribMask($0080);
private static _DEPTH_BUFFER_BIT := new AttribMask($0100);
private static _ACCUM_BUFFER_BIT := new AttribMask($0200);
private static _STENCIL_BUFFER_BIT := new AttribMask($0400);
private static _VIEWPORT_BIT := new AttribMask($0800);
private static _TRANSFORM_BIT := new AttribMask($1000);
private static _ENABLE_BIT := new AttribMask($2000);
private static _COLOR_BUFFER_BIT := new AttribMask($4000);
private static _HINT_BIT := new AttribMask($8000);
private static _EVAL_BIT := new AttribMask($10000);
private static _LIST_BIT := new AttribMask($20000);
private static _TEXTURE_BIT := new AttribMask($40000);
private static _SCISSOR_BIT := new AttribMask($80000);
private static _MULTISAMPLE_BIT := new AttribMask($20000000);
private static _MULTISAMPLE_BIT_3DFX := new AttribMask($20000000);
private static _MULTISAMPLE_BIT_ARB := new AttribMask($20000000);
private static _MULTISAMPLE_BIT_EXT := new AttribMask($20000000);
private static _ALL_ATTRIB_BITS := new AttribMask($FFFFFFFF);
public static property CURRENT_BIT: AttribMask read _CURRENT_BIT;
public static property POINT_BIT: AttribMask read _POINT_BIT;
public static property LINE_BIT: AttribMask read _LINE_BIT;
public static property POLYGON_BIT: AttribMask read _POLYGON_BIT;
public static property POLYGON_STIPPLE_BIT: AttribMask read _POLYGON_STIPPLE_BIT;
public static property PIXEL_MODE_BIT: AttribMask read _PIXEL_MODE_BIT;
public static property LIGHTING_BIT: AttribMask read _LIGHTING_BIT;
public static property FOG_BIT: AttribMask read _FOG_BIT;
public static property DEPTH_BUFFER_BIT: AttribMask read _DEPTH_BUFFER_BIT;
public static property ACCUM_BUFFER_BIT: AttribMask read _ACCUM_BUFFER_BIT;
public static property STENCIL_BUFFER_BIT: AttribMask read _STENCIL_BUFFER_BIT;
public static property VIEWPORT_BIT: AttribMask read _VIEWPORT_BIT;
public static property TRANSFORM_BIT: AttribMask read _TRANSFORM_BIT;
public static property ENABLE_BIT: AttribMask read _ENABLE_BIT;
public static property COLOR_BUFFER_BIT: AttribMask read _COLOR_BUFFER_BIT;
public static property HINT_BIT: AttribMask read _HINT_BIT;
public static property EVAL_BIT: AttribMask read _EVAL_BIT;
public static property LIST_BIT: AttribMask read _LIST_BIT;
public static property TEXTURE_BIT: AttribMask read _TEXTURE_BIT;
public static property SCISSOR_BIT: AttribMask read _SCISSOR_BIT;
public static property MULTISAMPLE_BIT: AttribMask read _MULTISAMPLE_BIT;
public static property MULTISAMPLE_BIT_3DFX: AttribMask read _MULTISAMPLE_BIT_3DFX;
public static property MULTISAMPLE_BIT_ARB: AttribMask read _MULTISAMPLE_BIT_ARB;
public static property MULTISAMPLE_BIT_EXT: AttribMask read _MULTISAMPLE_BIT_EXT;
public static property ALL_ATTRIB_BITS: AttribMask read _ALL_ATTRIB_BITS;
public static function operator or(f1,f2: AttribMask) := new AttribMask(f1.val or f2.val);
public property HAS_FLAG_CURRENT_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_POINT_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_LINE_BIT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_POLYGON_BIT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_POLYGON_STIPPLE_BIT: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_PIXEL_MODE_BIT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_LIGHTING_BIT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_FOG_BIT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_DEPTH_BUFFER_BIT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_ACCUM_BUFFER_BIT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_STENCIL_BUFFER_BIT: boolean read self.val and $0400 <> 0;
public property HAS_FLAG_VIEWPORT_BIT: boolean read self.val and $0800 <> 0;
public property HAS_FLAG_TRANSFORM_BIT: boolean read self.val and $1000 <> 0;
public property HAS_FLAG_ENABLE_BIT: boolean read self.val and $2000 <> 0;
public property HAS_FLAG_COLOR_BUFFER_BIT: boolean read self.val and $4000 <> 0;
public property HAS_FLAG_HINT_BIT: boolean read self.val and $8000 <> 0;
public property HAS_FLAG_EVAL_BIT: boolean read self.val and $10000 <> 0;
public property HAS_FLAG_LIST_BIT: boolean read self.val and $20000 <> 0;
public property HAS_FLAG_TEXTURE_BIT: boolean read self.val and $40000 <> 0;
public property HAS_FLAG_SCISSOR_BIT: boolean read self.val and $80000 <> 0;
public property HAS_FLAG_MULTISAMPLE_BIT: boolean read self.val and $20000000 <> 0;
public property HAS_FLAG_MULTISAMPLE_BIT_3DFX: boolean read self.val and $20000000 <> 0;
public property HAS_FLAG_MULTISAMPLE_BIT_ARB: boolean read self.val and $20000000 <> 0;
public property HAS_FLAG_MULTISAMPLE_BIT_EXT: boolean read self.val and $20000000 <> 0;
public property HAS_FLAG_ALL_ATTRIB_BITS: boolean read self.val and $FFFFFFFF <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'CURRENT_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'POINT_BIT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'LINE_BIT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'POLYGON_BIT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'POLYGON_STIPPLE_BIT+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'PIXEL_MODE_BIT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'LIGHTING_BIT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'FOG_BIT+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'DEPTH_BUFFER_BIT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'ACCUM_BUFFER_BIT+';
if self.val and UInt32($0400) = UInt32($0400) then res += 'STENCIL_BUFFER_BIT+';
if self.val and UInt32($0800) = UInt32($0800) then res += 'VIEWPORT_BIT+';
if self.val and UInt32($1000) = UInt32($1000) then res += 'TRANSFORM_BIT+';
if self.val and UInt32($2000) = UInt32($2000) then res += 'ENABLE_BIT+';
if self.val and UInt32($4000) = UInt32($4000) then res += 'COLOR_BUFFER_BIT+';
if self.val and UInt32($8000) = UInt32($8000) then res += 'HINT_BIT+';
if self.val and UInt32($10000) = UInt32($10000) then res += 'EVAL_BIT+';
if self.val and UInt32($20000) = UInt32($20000) then res += 'LIST_BIT+';
if self.val and UInt32($40000) = UInt32($40000) then res += 'TEXTURE_BIT+';
if self.val and UInt32($80000) = UInt32($80000) then res += 'SCISSOR_BIT+';
if self.val and UInt32($20000000) = UInt32($20000000) then res += 'MULTISAMPLE_BIT+';
if self.val and UInt32($20000000) = UInt32($20000000) then res += 'MULTISAMPLE_BIT_3DFX+';
if self.val and UInt32($20000000) = UInt32($20000000) then res += 'MULTISAMPLE_BIT_ARB+';
if self.val and UInt32($20000000) = UInt32($20000000) then res += 'MULTISAMPLE_BIT_EXT+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'ALL_ATTRIB_BITS+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
AttributeType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INT := new AttributeType($1404);
private static _UNSIGNED_INT := new AttributeType($1405);
private static _FLOAT := new AttributeType($1406);
private static _DOUBLE := new AttributeType($140A);
private static _INT64_ARB := new AttributeType($140E);
private static _INT64_NV := new AttributeType($140E);
private static _UNSIGNED_INT64_ARB := new AttributeType($140F);
private static _UNSIGNED_INT64_NV := new AttributeType($140F);
private static _FLOAT_VEC2 := new AttributeType($8B50);
private static _FLOAT_VEC2_ARB := new AttributeType($8B50);
private static _FLOAT_VEC3 := new AttributeType($8B51);
private static _FLOAT_VEC3_ARB := new AttributeType($8B51);
private static _FLOAT_VEC4 := new AttributeType($8B52);
private static _FLOAT_VEC4_ARB := new AttributeType($8B52);
private static _INT_VEC2 := new AttributeType($8B53);
private static _INT_VEC2_ARB := new AttributeType($8B53);
private static _INT_VEC3 := new AttributeType($8B54);
private static _INT_VEC3_ARB := new AttributeType($8B54);
private static _INT_VEC4 := new AttributeType($8B55);
private static _INT_VEC4_ARB := new AttributeType($8B55);
private static _BOOL := new AttributeType($8B56);
private static _BOOL_ARB := new AttributeType($8B56);
private static _BOOL_VEC2 := new AttributeType($8B57);
private static _BOOL_VEC2_ARB := new AttributeType($8B57);
private static _BOOL_VEC3 := new AttributeType($8B58);
private static _BOOL_VEC3_ARB := new AttributeType($8B58);
private static _BOOL_VEC4 := new AttributeType($8B59);
private static _BOOL_VEC4_ARB := new AttributeType($8B59);
private static _FLOAT_MAT2 := new AttributeType($8B5A);
private static _FLOAT_MAT2_ARB := new AttributeType($8B5A);
private static _FLOAT_MAT3 := new AttributeType($8B5B);
private static _FLOAT_MAT3_ARB := new AttributeType($8B5B);
private static _FLOAT_MAT4 := new AttributeType($8B5C);
private static _FLOAT_MAT4_ARB := new AttributeType($8B5C);
private static _SAMPLER_1D := new AttributeType($8B5D);
private static _SAMPLER_1D_ARB := new AttributeType($8B5D);
private static _SAMPLER_2D := new AttributeType($8B5E);
private static _SAMPLER_2D_ARB := new AttributeType($8B5E);
private static _SAMPLER_3D := new AttributeType($8B5F);
private static _SAMPLER_3D_ARB := new AttributeType($8B5F);
private static _SAMPLER_3D_OES := new AttributeType($8B5F);
private static _SAMPLER_CUBE := new AttributeType($8B60);
private static _SAMPLER_CUBE_ARB := new AttributeType($8B60);
private static _SAMPLER_1D_SHADOW := new AttributeType($8B61);
private static _SAMPLER_1D_SHADOW_ARB := new AttributeType($8B61);
private static _SAMPLER_2D_SHADOW := new AttributeType($8B62);
private static _SAMPLER_2D_SHADOW_ARB := new AttributeType($8B62);
private static _SAMPLER_2D_SHADOW_EXT := new AttributeType($8B62);
private static _SAMPLER_2D_RECT := new AttributeType($8B63);
private static _SAMPLER_2D_RECT_ARB := new AttributeType($8B63);
private static _SAMPLER_2D_RECT_SHADOW := new AttributeType($8B64);
private static _SAMPLER_2D_RECT_SHADOW_ARB := new AttributeType($8B64);
private static _FLOAT_MAT2x3 := new AttributeType($8B65);
private static _FLOAT_MAT2x3_NV := new AttributeType($8B65);
private static _FLOAT_MAT2x4 := new AttributeType($8B66);
private static _FLOAT_MAT2x4_NV := new AttributeType($8B66);
private static _FLOAT_MAT3x2 := new AttributeType($8B67);
private static _FLOAT_MAT3x2_NV := new AttributeType($8B67);
private static _FLOAT_MAT3x4 := new AttributeType($8B68);
private static _FLOAT_MAT3x4_NV := new AttributeType($8B68);
private static _FLOAT_MAT4x2 := new AttributeType($8B69);
private static _FLOAT_MAT4x2_NV := new AttributeType($8B69);
private static _FLOAT_MAT4x3 := new AttributeType($8B6A);
private static _FLOAT_MAT4x3_NV := new AttributeType($8B6A);
private static _SAMPLER_BUFFER := new AttributeType($8DC2);
private static _SAMPLER_1D_ARRAY_SHADOW := new AttributeType($8DC3);
private static _SAMPLER_2D_ARRAY_SHADOW := new AttributeType($8DC4);
private static _SAMPLER_CUBE_SHADOW := new AttributeType($8DC5);
private static _UNSIGNED_INT_VEC2 := new AttributeType($8DC6);
private static _UNSIGNED_INT_VEC3 := new AttributeType($8DC7);
private static _UNSIGNED_INT_VEC4 := new AttributeType($8DC8);
private static _INT_SAMPLER_1D := new AttributeType($8DC9);
private static _INT_SAMPLER_2D := new AttributeType($8DCA);
private static _INT_SAMPLER_3D := new AttributeType($8DCB);
private static _INT_SAMPLER_CUBE := new AttributeType($8DCC);
private static _INT_SAMPLER_2D_RECT := new AttributeType($8DCD);
private static _INT_SAMPLER_1D_ARRAY := new AttributeType($8DCE);
private static _INT_SAMPLER_2D_ARRAY := new AttributeType($8DCF);
private static _INT_SAMPLER_BUFFER := new AttributeType($8DD0);
private static _UNSIGNED_INT_SAMPLER_1D := new AttributeType($8DD1);
private static _UNSIGNED_INT_SAMPLER_2D := new AttributeType($8DD2);
private static _UNSIGNED_INT_SAMPLER_3D := new AttributeType($8DD3);
private static _UNSIGNED_INT_SAMPLER_CUBE := new AttributeType($8DD4);
private static _UNSIGNED_INT_SAMPLER_2D_RECT := new AttributeType($8DD5);
private static _UNSIGNED_INT_SAMPLER_1D_ARRAY := new AttributeType($8DD6);
private static _UNSIGNED_INT_SAMPLER_2D_ARRAY := new AttributeType($8DD7);
private static _UNSIGNED_INT_SAMPLER_BUFFER := new AttributeType($8DD8);
private static _DOUBLE_MAT2 := new AttributeType($8F46);
private static _DOUBLE_MAT3 := new AttributeType($8F47);
private static _DOUBLE_MAT4 := new AttributeType($8F48);
private static _DOUBLE_MAT2x3 := new AttributeType($8F49);
private static _DOUBLE_MAT2x4 := new AttributeType($8F4A);
private static _DOUBLE_MAT3x2 := new AttributeType($8F4B);
private static _DOUBLE_MAT3x4 := new AttributeType($8F4C);
private static _DOUBLE_MAT4x2 := new AttributeType($8F4D);
private static _DOUBLE_MAT4x3 := new AttributeType($8F4E);
private static _INT64_VEC2_ARB := new AttributeType($8FE9);
private static _INT64_VEC3_ARB := new AttributeType($8FEA);
private static _INT64_VEC4_ARB := new AttributeType($8FEB);
private static _UNSIGNED_INT64_VEC2_ARB := new AttributeType($8FF5);
private static _UNSIGNED_INT64_VEC3_ARB := new AttributeType($8FF6);
private static _UNSIGNED_INT64_VEC4_ARB := new AttributeType($8FF7);
private static _DOUBLE_VEC2 := new AttributeType($8FFC);
private static _DOUBLE_VEC3 := new AttributeType($8FFD);
private static _DOUBLE_VEC4 := new AttributeType($8FFE);
private static _SAMPLER_CUBE_MAP_ARRAY := new AttributeType($900C);
private static _SAMPLER_CUBE_MAP_ARRAY_SHADOW := new AttributeType($900D);
private static _INT_SAMPLER_CUBE_MAP_ARRAY := new AttributeType($900E);
private static _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY := new AttributeType($900F);
private static _IMAGE_1D := new AttributeType($904C);
private static _IMAGE_2D := new AttributeType($904D);
private static _IMAGE_3D := new AttributeType($904E);
private static _IMAGE_2D_RECT := new AttributeType($904F);
private static _IMAGE_CUBE := new AttributeType($9050);
private static _IMAGE_BUFFER := new AttributeType($9051);
private static _IMAGE_1D_ARRAY := new AttributeType($9052);
private static _IMAGE_2D_ARRAY := new AttributeType($9053);
private static _IMAGE_CUBE_MAP_ARRAY := new AttributeType($9054);
private static _IMAGE_2D_MULTISAMPLE := new AttributeType($9055);
private static _IMAGE_2D_MULTISAMPLE_ARRAY := new AttributeType($9056);
private static _INT_IMAGE_1D := new AttributeType($9057);
private static _INT_IMAGE_2D := new AttributeType($9058);
private static _INT_IMAGE_3D := new AttributeType($9059);
private static _INT_IMAGE_2D_RECT := new AttributeType($905A);
private static _INT_IMAGE_CUBE := new AttributeType($905B);
private static _INT_IMAGE_BUFFER := new AttributeType($905C);
private static _INT_IMAGE_1D_ARRAY := new AttributeType($905D);
private static _INT_IMAGE_2D_ARRAY := new AttributeType($905E);
private static _INT_IMAGE_CUBE_MAP_ARRAY := new AttributeType($905F);
private static _INT_IMAGE_2D_MULTISAMPLE := new AttributeType($9060);
private static _INT_IMAGE_2D_MULTISAMPLE_ARRAY := new AttributeType($9061);
private static _UNSIGNED_INT_IMAGE_1D := new AttributeType($9062);
private static _UNSIGNED_INT_IMAGE_2D := new AttributeType($9063);
private static _UNSIGNED_INT_IMAGE_3D := new AttributeType($9064);
private static _UNSIGNED_INT_IMAGE_2D_RECT := new AttributeType($9065);
private static _UNSIGNED_INT_IMAGE_CUBE := new AttributeType($9066);
private static _UNSIGNED_INT_IMAGE_BUFFER := new AttributeType($9067);
private static _UNSIGNED_INT_IMAGE_1D_ARRAY := new AttributeType($9068);
private static _UNSIGNED_INT_IMAGE_2D_ARRAY := new AttributeType($9069);
private static _UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY := new AttributeType($906A);
private static _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE := new AttributeType($906B);
private static _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY := new AttributeType($906C);
private static _SAMPLER_2D_MULTISAMPLE := new AttributeType($9108);
private static _INT_SAMPLER_2D_MULTISAMPLE := new AttributeType($9109);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE := new AttributeType($910A);
private static _SAMPLER_2D_MULTISAMPLE_ARRAY := new AttributeType($910B);
private static _INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new AttributeType($910C);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new AttributeType($910D);
public static property INT: AttributeType read _INT;
public static property UNSIGNED_INT: AttributeType read _UNSIGNED_INT;
public static property FLOAT: AttributeType read _FLOAT;
public static property DOUBLE: AttributeType read _DOUBLE;
public static property INT64_ARB: AttributeType read _INT64_ARB;
public static property INT64_NV: AttributeType read _INT64_NV;
public static property UNSIGNED_INT64_ARB: AttributeType read _UNSIGNED_INT64_ARB;
public static property UNSIGNED_INT64_NV: AttributeType read _UNSIGNED_INT64_NV;
public static property FLOAT_VEC2: AttributeType read _FLOAT_VEC2;
public static property FLOAT_VEC2_ARB: AttributeType read _FLOAT_VEC2_ARB;
public static property FLOAT_VEC3: AttributeType read _FLOAT_VEC3;
public static property FLOAT_VEC3_ARB: AttributeType read _FLOAT_VEC3_ARB;
public static property FLOAT_VEC4: AttributeType read _FLOAT_VEC4;
public static property FLOAT_VEC4_ARB: AttributeType read _FLOAT_VEC4_ARB;
public static property INT_VEC2: AttributeType read _INT_VEC2;
public static property INT_VEC2_ARB: AttributeType read _INT_VEC2_ARB;
public static property INT_VEC3: AttributeType read _INT_VEC3;
public static property INT_VEC3_ARB: AttributeType read _INT_VEC3_ARB;
public static property INT_VEC4: AttributeType read _INT_VEC4;
public static property INT_VEC4_ARB: AttributeType read _INT_VEC4_ARB;
public static property BOOL: AttributeType read _BOOL;
public static property BOOL_ARB: AttributeType read _BOOL_ARB;
public static property BOOL_VEC2: AttributeType read _BOOL_VEC2;
public static property BOOL_VEC2_ARB: AttributeType read _BOOL_VEC2_ARB;
public static property BOOL_VEC3: AttributeType read _BOOL_VEC3;
public static property BOOL_VEC3_ARB: AttributeType read _BOOL_VEC3_ARB;
public static property BOOL_VEC4: AttributeType read _BOOL_VEC4;
public static property BOOL_VEC4_ARB: AttributeType read _BOOL_VEC4_ARB;
public static property FLOAT_MAT2: AttributeType read _FLOAT_MAT2;
public static property FLOAT_MAT2_ARB: AttributeType read _FLOAT_MAT2_ARB;
public static property FLOAT_MAT3: AttributeType read _FLOAT_MAT3;
public static property FLOAT_MAT3_ARB: AttributeType read _FLOAT_MAT3_ARB;
public static property FLOAT_MAT4: AttributeType read _FLOAT_MAT4;
public static property FLOAT_MAT4_ARB: AttributeType read _FLOAT_MAT4_ARB;
public static property SAMPLER_1D: AttributeType read _SAMPLER_1D;
public static property SAMPLER_1D_ARB: AttributeType read _SAMPLER_1D_ARB;
public static property SAMPLER_2D: AttributeType read _SAMPLER_2D;
public static property SAMPLER_2D_ARB: AttributeType read _SAMPLER_2D_ARB;
public static property SAMPLER_3D: AttributeType read _SAMPLER_3D;
public static property SAMPLER_3D_ARB: AttributeType read _SAMPLER_3D_ARB;
public static property SAMPLER_3D_OES: AttributeType read _SAMPLER_3D_OES;
public static property SAMPLER_CUBE: AttributeType read _SAMPLER_CUBE;
public static property SAMPLER_CUBE_ARB: AttributeType read _SAMPLER_CUBE_ARB;
public static property SAMPLER_1D_SHADOW: AttributeType read _SAMPLER_1D_SHADOW;
public static property SAMPLER_1D_SHADOW_ARB: AttributeType read _SAMPLER_1D_SHADOW_ARB;
public static property SAMPLER_2D_SHADOW: AttributeType read _SAMPLER_2D_SHADOW;
public static property SAMPLER_2D_SHADOW_ARB: AttributeType read _SAMPLER_2D_SHADOW_ARB;
public static property SAMPLER_2D_SHADOW_EXT: AttributeType read _SAMPLER_2D_SHADOW_EXT;
public static property SAMPLER_2D_RECT: AttributeType read _SAMPLER_2D_RECT;
public static property SAMPLER_2D_RECT_ARB: AttributeType read _SAMPLER_2D_RECT_ARB;
public static property SAMPLER_2D_RECT_SHADOW: AttributeType read _SAMPLER_2D_RECT_SHADOW;
public static property SAMPLER_2D_RECT_SHADOW_ARB: AttributeType read _SAMPLER_2D_RECT_SHADOW_ARB;
public static property FLOAT_MAT2x3: AttributeType read _FLOAT_MAT2x3;
public static property FLOAT_MAT2x3_NV: AttributeType read _FLOAT_MAT2x3_NV;
public static property FLOAT_MAT2x4: AttributeType read _FLOAT_MAT2x4;
public static property FLOAT_MAT2x4_NV: AttributeType read _FLOAT_MAT2x4_NV;
public static property FLOAT_MAT3x2: AttributeType read _FLOAT_MAT3x2;
public static property FLOAT_MAT3x2_NV: AttributeType read _FLOAT_MAT3x2_NV;
public static property FLOAT_MAT3x4: AttributeType read _FLOAT_MAT3x4;
public static property FLOAT_MAT3x4_NV: AttributeType read _FLOAT_MAT3x4_NV;
public static property FLOAT_MAT4x2: AttributeType read _FLOAT_MAT4x2;
public static property FLOAT_MAT4x2_NV: AttributeType read _FLOAT_MAT4x2_NV;
public static property FLOAT_MAT4x3: AttributeType read _FLOAT_MAT4x3;
public static property FLOAT_MAT4x3_NV: AttributeType read _FLOAT_MAT4x3_NV;
public static property SAMPLER_BUFFER: AttributeType read _SAMPLER_BUFFER;
public static property SAMPLER_1D_ARRAY_SHADOW: AttributeType read _SAMPLER_1D_ARRAY_SHADOW;
public static property SAMPLER_2D_ARRAY_SHADOW: AttributeType read _SAMPLER_2D_ARRAY_SHADOW;
public static property SAMPLER_CUBE_SHADOW: AttributeType read _SAMPLER_CUBE_SHADOW;
public static property UNSIGNED_INT_VEC2: AttributeType read _UNSIGNED_INT_VEC2;
public static property UNSIGNED_INT_VEC3: AttributeType read _UNSIGNED_INT_VEC3;
public static property UNSIGNED_INT_VEC4: AttributeType read _UNSIGNED_INT_VEC4;
public static property INT_SAMPLER_1D: AttributeType read _INT_SAMPLER_1D;
public static property INT_SAMPLER_2D: AttributeType read _INT_SAMPLER_2D;
public static property INT_SAMPLER_3D: AttributeType read _INT_SAMPLER_3D;
public static property INT_SAMPLER_CUBE: AttributeType read _INT_SAMPLER_CUBE;
public static property INT_SAMPLER_2D_RECT: AttributeType read _INT_SAMPLER_2D_RECT;
public static property INT_SAMPLER_1D_ARRAY: AttributeType read _INT_SAMPLER_1D_ARRAY;
public static property INT_SAMPLER_2D_ARRAY: AttributeType read _INT_SAMPLER_2D_ARRAY;
public static property INT_SAMPLER_BUFFER: AttributeType read _INT_SAMPLER_BUFFER;
public static property UNSIGNED_INT_SAMPLER_1D: AttributeType read _UNSIGNED_INT_SAMPLER_1D;
public static property UNSIGNED_INT_SAMPLER_2D: AttributeType read _UNSIGNED_INT_SAMPLER_2D;
public static property UNSIGNED_INT_SAMPLER_3D: AttributeType read _UNSIGNED_INT_SAMPLER_3D;
public static property UNSIGNED_INT_SAMPLER_CUBE: AttributeType read _UNSIGNED_INT_SAMPLER_CUBE;
public static property UNSIGNED_INT_SAMPLER_2D_RECT: AttributeType read _UNSIGNED_INT_SAMPLER_2D_RECT;
public static property UNSIGNED_INT_SAMPLER_1D_ARRAY: AttributeType read _UNSIGNED_INT_SAMPLER_1D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_ARRAY: AttributeType read _UNSIGNED_INT_SAMPLER_2D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_BUFFER: AttributeType read _UNSIGNED_INT_SAMPLER_BUFFER;
public static property DOUBLE_MAT2: AttributeType read _DOUBLE_MAT2;
public static property DOUBLE_MAT3: AttributeType read _DOUBLE_MAT3;
public static property DOUBLE_MAT4: AttributeType read _DOUBLE_MAT4;
public static property DOUBLE_MAT2x3: AttributeType read _DOUBLE_MAT2x3;
public static property DOUBLE_MAT2x4: AttributeType read _DOUBLE_MAT2x4;
public static property DOUBLE_MAT3x2: AttributeType read _DOUBLE_MAT3x2;
public static property DOUBLE_MAT3x4: AttributeType read _DOUBLE_MAT3x4;
public static property DOUBLE_MAT4x2: AttributeType read _DOUBLE_MAT4x2;
public static property DOUBLE_MAT4x3: AttributeType read _DOUBLE_MAT4x3;
public static property INT64_VEC2_ARB: AttributeType read _INT64_VEC2_ARB;
public static property INT64_VEC3_ARB: AttributeType read _INT64_VEC3_ARB;
public static property INT64_VEC4_ARB: AttributeType read _INT64_VEC4_ARB;
public static property UNSIGNED_INT64_VEC2_ARB: AttributeType read _UNSIGNED_INT64_VEC2_ARB;
public static property UNSIGNED_INT64_VEC3_ARB: AttributeType read _UNSIGNED_INT64_VEC3_ARB;
public static property UNSIGNED_INT64_VEC4_ARB: AttributeType read _UNSIGNED_INT64_VEC4_ARB;
public static property DOUBLE_VEC2: AttributeType read _DOUBLE_VEC2;
public static property DOUBLE_VEC3: AttributeType read _DOUBLE_VEC3;
public static property DOUBLE_VEC4: AttributeType read _DOUBLE_VEC4;
public static property SAMPLER_CUBE_MAP_ARRAY: AttributeType read _SAMPLER_CUBE_MAP_ARRAY;
public static property SAMPLER_CUBE_MAP_ARRAY_SHADOW: AttributeType read _SAMPLER_CUBE_MAP_ARRAY_SHADOW;
public static property INT_SAMPLER_CUBE_MAP_ARRAY: AttributeType read _INT_SAMPLER_CUBE_MAP_ARRAY;
public static property UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: AttributeType read _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY;
public static property IMAGE_1D: AttributeType read _IMAGE_1D;
public static property IMAGE_2D: AttributeType read _IMAGE_2D;
public static property IMAGE_3D: AttributeType read _IMAGE_3D;
public static property IMAGE_2D_RECT: AttributeType read _IMAGE_2D_RECT;
public static property IMAGE_CUBE: AttributeType read _IMAGE_CUBE;
public static property IMAGE_BUFFER: AttributeType read _IMAGE_BUFFER;
public static property IMAGE_1D_ARRAY: AttributeType read _IMAGE_1D_ARRAY;
public static property IMAGE_2D_ARRAY: AttributeType read _IMAGE_2D_ARRAY;
public static property IMAGE_CUBE_MAP_ARRAY: AttributeType read _IMAGE_CUBE_MAP_ARRAY;
public static property IMAGE_2D_MULTISAMPLE: AttributeType read _IMAGE_2D_MULTISAMPLE;
public static property IMAGE_2D_MULTISAMPLE_ARRAY: AttributeType read _IMAGE_2D_MULTISAMPLE_ARRAY;
public static property INT_IMAGE_1D: AttributeType read _INT_IMAGE_1D;
public static property INT_IMAGE_2D: AttributeType read _INT_IMAGE_2D;
public static property INT_IMAGE_3D: AttributeType read _INT_IMAGE_3D;
public static property INT_IMAGE_2D_RECT: AttributeType read _INT_IMAGE_2D_RECT;
public static property INT_IMAGE_CUBE: AttributeType read _INT_IMAGE_CUBE;
public static property INT_IMAGE_BUFFER: AttributeType read _INT_IMAGE_BUFFER;
public static property INT_IMAGE_1D_ARRAY: AttributeType read _INT_IMAGE_1D_ARRAY;
public static property INT_IMAGE_2D_ARRAY: AttributeType read _INT_IMAGE_2D_ARRAY;
public static property INT_IMAGE_CUBE_MAP_ARRAY: AttributeType read _INT_IMAGE_CUBE_MAP_ARRAY;
public static property INT_IMAGE_2D_MULTISAMPLE: AttributeType read _INT_IMAGE_2D_MULTISAMPLE;
public static property INT_IMAGE_2D_MULTISAMPLE_ARRAY: AttributeType read _INT_IMAGE_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_IMAGE_1D: AttributeType read _UNSIGNED_INT_IMAGE_1D;
public static property UNSIGNED_INT_IMAGE_2D: AttributeType read _UNSIGNED_INT_IMAGE_2D;
public static property UNSIGNED_INT_IMAGE_3D: AttributeType read _UNSIGNED_INT_IMAGE_3D;
public static property UNSIGNED_INT_IMAGE_2D_RECT: AttributeType read _UNSIGNED_INT_IMAGE_2D_RECT;
public static property UNSIGNED_INT_IMAGE_CUBE: AttributeType read _UNSIGNED_INT_IMAGE_CUBE;
public static property UNSIGNED_INT_IMAGE_BUFFER: AttributeType read _UNSIGNED_INT_IMAGE_BUFFER;
public static property UNSIGNED_INT_IMAGE_1D_ARRAY: AttributeType read _UNSIGNED_INT_IMAGE_1D_ARRAY;
public static property UNSIGNED_INT_IMAGE_2D_ARRAY: AttributeType read _UNSIGNED_INT_IMAGE_2D_ARRAY;
public static property UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY: AttributeType read _UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY;
public static property UNSIGNED_INT_IMAGE_2D_MULTISAMPLE: AttributeType read _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
public static property UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: AttributeType read _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY;
public static property SAMPLER_2D_MULTISAMPLE: AttributeType read _SAMPLER_2D_MULTISAMPLE;
public static property INT_SAMPLER_2D_MULTISAMPLE: AttributeType read _INT_SAMPLER_2D_MULTISAMPLE;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: AttributeType read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
public static property SAMPLER_2D_MULTISAMPLE_ARRAY: AttributeType read _SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property INT_SAMPLER_2D_MULTISAMPLE_ARRAY: AttributeType read _INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: AttributeType read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public function ToString: string; override;
begin
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($140E) then Result := 'INT64_ARB' else
if self.val = UInt32($140E) then Result := 'INT64_NV' else
if self.val = UInt32($140F) then Result := 'UNSIGNED_INT64_ARB' else
if self.val = UInt32($140F) then Result := 'UNSIGNED_INT64_NV' else
if self.val = UInt32($8B50) then Result := 'FLOAT_VEC2' else
if self.val = UInt32($8B50) then Result := 'FLOAT_VEC2_ARB' else
if self.val = UInt32($8B51) then Result := 'FLOAT_VEC3' else
if self.val = UInt32($8B51) then Result := 'FLOAT_VEC3_ARB' else
if self.val = UInt32($8B52) then Result := 'FLOAT_VEC4' else
if self.val = UInt32($8B52) then Result := 'FLOAT_VEC4_ARB' else
if self.val = UInt32($8B53) then Result := 'INT_VEC2' else
if self.val = UInt32($8B53) then Result := 'INT_VEC2_ARB' else
if self.val = UInt32($8B54) then Result := 'INT_VEC3' else
if self.val = UInt32($8B54) then Result := 'INT_VEC3_ARB' else
if self.val = UInt32($8B55) then Result := 'INT_VEC4' else
if self.val = UInt32($8B55) then Result := 'INT_VEC4_ARB' else
if self.val = UInt32($8B56) then Result := 'BOOL' else
if self.val = UInt32($8B56) then Result := 'BOOL_ARB' else
if self.val = UInt32($8B57) then Result := 'BOOL_VEC2' else
if self.val = UInt32($8B57) then Result := 'BOOL_VEC2_ARB' else
if self.val = UInt32($8B58) then Result := 'BOOL_VEC3' else
if self.val = UInt32($8B58) then Result := 'BOOL_VEC3_ARB' else
if self.val = UInt32($8B59) then Result := 'BOOL_VEC4' else
if self.val = UInt32($8B59) then Result := 'BOOL_VEC4_ARB' else
if self.val = UInt32($8B5A) then Result := 'FLOAT_MAT2' else
if self.val = UInt32($8B5A) then Result := 'FLOAT_MAT2_ARB' else
if self.val = UInt32($8B5B) then Result := 'FLOAT_MAT3' else
if self.val = UInt32($8B5B) then Result := 'FLOAT_MAT3_ARB' else
if self.val = UInt32($8B5C) then Result := 'FLOAT_MAT4' else
if self.val = UInt32($8B5C) then Result := 'FLOAT_MAT4_ARB' else
if self.val = UInt32($8B5D) then Result := 'SAMPLER_1D' else
if self.val = UInt32($8B5D) then Result := 'SAMPLER_1D_ARB' else
if self.val = UInt32($8B5E) then Result := 'SAMPLER_2D' else
if self.val = UInt32($8B5E) then Result := 'SAMPLER_2D_ARB' else
if self.val = UInt32($8B5F) then Result := 'SAMPLER_3D' else
if self.val = UInt32($8B5F) then Result := 'SAMPLER_3D_ARB' else
if self.val = UInt32($8B5F) then Result := 'SAMPLER_3D_OES' else
if self.val = UInt32($8B60) then Result := 'SAMPLER_CUBE' else
if self.val = UInt32($8B60) then Result := 'SAMPLER_CUBE_ARB' else
if self.val = UInt32($8B61) then Result := 'SAMPLER_1D_SHADOW' else
if self.val = UInt32($8B61) then Result := 'SAMPLER_1D_SHADOW_ARB' else
if self.val = UInt32($8B62) then Result := 'SAMPLER_2D_SHADOW' else
if self.val = UInt32($8B62) then Result := 'SAMPLER_2D_SHADOW_ARB' else
if self.val = UInt32($8B62) then Result := 'SAMPLER_2D_SHADOW_EXT' else
if self.val = UInt32($8B63) then Result := 'SAMPLER_2D_RECT' else
if self.val = UInt32($8B63) then Result := 'SAMPLER_2D_RECT_ARB' else
if self.val = UInt32($8B64) then Result := 'SAMPLER_2D_RECT_SHADOW' else
if self.val = UInt32($8B64) then Result := 'SAMPLER_2D_RECT_SHADOW_ARB' else
if self.val = UInt32($8B65) then Result := 'FLOAT_MAT2x3' else
if self.val = UInt32($8B65) then Result := 'FLOAT_MAT2x3_NV' else
if self.val = UInt32($8B66) then Result := 'FLOAT_MAT2x4' else
if self.val = UInt32($8B66) then Result := 'FLOAT_MAT2x4_NV' else
if self.val = UInt32($8B67) then Result := 'FLOAT_MAT3x2' else
if self.val = UInt32($8B67) then Result := 'FLOAT_MAT3x2_NV' else
if self.val = UInt32($8B68) then Result := 'FLOAT_MAT3x4' else
if self.val = UInt32($8B68) then Result := 'FLOAT_MAT3x4_NV' else
if self.val = UInt32($8B69) then Result := 'FLOAT_MAT4x2' else
if self.val = UInt32($8B69) then Result := 'FLOAT_MAT4x2_NV' else
if self.val = UInt32($8B6A) then Result := 'FLOAT_MAT4x3' else
if self.val = UInt32($8B6A) then Result := 'FLOAT_MAT4x3_NV' else
if self.val = UInt32($8DC2) then Result := 'SAMPLER_BUFFER' else
if self.val = UInt32($8DC3) then Result := 'SAMPLER_1D_ARRAY_SHADOW' else
if self.val = UInt32($8DC4) then Result := 'SAMPLER_2D_ARRAY_SHADOW' else
if self.val = UInt32($8DC5) then Result := 'SAMPLER_CUBE_SHADOW' else
if self.val = UInt32($8DC6) then Result := 'UNSIGNED_INT_VEC2' else
if self.val = UInt32($8DC7) then Result := 'UNSIGNED_INT_VEC3' else
if self.val = UInt32($8DC8) then Result := 'UNSIGNED_INT_VEC4' else
if self.val = UInt32($8DC9) then Result := 'INT_SAMPLER_1D' else
if self.val = UInt32($8DCA) then Result := 'INT_SAMPLER_2D' else
if self.val = UInt32($8DCB) then Result := 'INT_SAMPLER_3D' else
if self.val = UInt32($8DCC) then Result := 'INT_SAMPLER_CUBE' else
if self.val = UInt32($8DCD) then Result := 'INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DCE) then Result := 'INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DCF) then Result := 'INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD0) then Result := 'INT_SAMPLER_BUFFER' else
if self.val = UInt32($8DD1) then Result := 'UNSIGNED_INT_SAMPLER_1D' else
if self.val = UInt32($8DD2) then Result := 'UNSIGNED_INT_SAMPLER_2D' else
if self.val = UInt32($8DD3) then Result := 'UNSIGNED_INT_SAMPLER_3D' else
if self.val = UInt32($8DD4) then Result := 'UNSIGNED_INT_SAMPLER_CUBE' else
if self.val = UInt32($8DD5) then Result := 'UNSIGNED_INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DD6) then Result := 'UNSIGNED_INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DD7) then Result := 'UNSIGNED_INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD8) then Result := 'UNSIGNED_INT_SAMPLER_BUFFER' else
if self.val = UInt32($8F46) then Result := 'DOUBLE_MAT2' else
if self.val = UInt32($8F47) then Result := 'DOUBLE_MAT3' else
if self.val = UInt32($8F48) then Result := 'DOUBLE_MAT4' else
if self.val = UInt32($8F49) then Result := 'DOUBLE_MAT2x3' else
if self.val = UInt32($8F4A) then Result := 'DOUBLE_MAT2x4' else
if self.val = UInt32($8F4B) then Result := 'DOUBLE_MAT3x2' else
if self.val = UInt32($8F4C) then Result := 'DOUBLE_MAT3x4' else
if self.val = UInt32($8F4D) then Result := 'DOUBLE_MAT4x2' else
if self.val = UInt32($8F4E) then Result := 'DOUBLE_MAT4x3' else
if self.val = UInt32($8FE9) then Result := 'INT64_VEC2_ARB' else
if self.val = UInt32($8FEA) then Result := 'INT64_VEC3_ARB' else
if self.val = UInt32($8FEB) then Result := 'INT64_VEC4_ARB' else
if self.val = UInt32($8FF5) then Result := 'UNSIGNED_INT64_VEC2_ARB' else
if self.val = UInt32($8FF6) then Result := 'UNSIGNED_INT64_VEC3_ARB' else
if self.val = UInt32($8FF7) then Result := 'UNSIGNED_INT64_VEC4_ARB' else
if self.val = UInt32($8FFC) then Result := 'DOUBLE_VEC2' else
if self.val = UInt32($8FFD) then Result := 'DOUBLE_VEC3' else
if self.val = UInt32($8FFE) then Result := 'DOUBLE_VEC4' else
if self.val = UInt32($900C) then Result := 'SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900D) then Result := 'SAMPLER_CUBE_MAP_ARRAY_SHADOW' else
if self.val = UInt32($900E) then Result := 'INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900F) then Result := 'UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($904C) then Result := 'IMAGE_1D' else
if self.val = UInt32($904D) then Result := 'IMAGE_2D' else
if self.val = UInt32($904E) then Result := 'IMAGE_3D' else
if self.val = UInt32($904F) then Result := 'IMAGE_2D_RECT' else
if self.val = UInt32($9050) then Result := 'IMAGE_CUBE' else
if self.val = UInt32($9051) then Result := 'IMAGE_BUFFER' else
if self.val = UInt32($9052) then Result := 'IMAGE_1D_ARRAY' else
if self.val = UInt32($9053) then Result := 'IMAGE_2D_ARRAY' else
if self.val = UInt32($9054) then Result := 'IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9055) then Result := 'IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($9056) then Result := 'IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9057) then Result := 'INT_IMAGE_1D' else
if self.val = UInt32($9058) then Result := 'INT_IMAGE_2D' else
if self.val = UInt32($9059) then Result := 'INT_IMAGE_3D' else
if self.val = UInt32($905A) then Result := 'INT_IMAGE_2D_RECT' else
if self.val = UInt32($905B) then Result := 'INT_IMAGE_CUBE' else
if self.val = UInt32($905C) then Result := 'INT_IMAGE_BUFFER' else
if self.val = UInt32($905D) then Result := 'INT_IMAGE_1D_ARRAY' else
if self.val = UInt32($905E) then Result := 'INT_IMAGE_2D_ARRAY' else
if self.val = UInt32($905F) then Result := 'INT_IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9060) then Result := 'INT_IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($9061) then Result := 'INT_IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9062) then Result := 'UNSIGNED_INT_IMAGE_1D' else
if self.val = UInt32($9063) then Result := 'UNSIGNED_INT_IMAGE_2D' else
if self.val = UInt32($9064) then Result := 'UNSIGNED_INT_IMAGE_3D' else
if self.val = UInt32($9065) then Result := 'UNSIGNED_INT_IMAGE_2D_RECT' else
if self.val = UInt32($9066) then Result := 'UNSIGNED_INT_IMAGE_CUBE' else
if self.val = UInt32($9067) then Result := 'UNSIGNED_INT_IMAGE_BUFFER' else
if self.val = UInt32($9068) then Result := 'UNSIGNED_INT_IMAGE_1D_ARRAY' else
if self.val = UInt32($9069) then Result := 'UNSIGNED_INT_IMAGE_2D_ARRAY' else
if self.val = UInt32($906A) then Result := 'UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($906B) then Result := 'UNSIGNED_INT_IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($906C) then Result := 'UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9108) then Result := 'SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($9109) then Result := 'INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910A) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910B) then Result := 'SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910C) then Result := 'INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910D) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
Result := self.val.ToString;
end;
end;
BindTransformFeedbackTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TRANSFORM_FEEDBACK := new BindTransformFeedbackTarget($8E22);
public static property TRANSFORM_FEEDBACK: BindTransformFeedbackTarget read _TRANSFORM_FEEDBACK;
public function ToString: string; override;
begin
if self.val = UInt32($8E22) then Result := 'TRANSFORM_FEEDBACK' else
Result := self.val.ToString;
end;
end;
BlendingFactor = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ZERO := new BlendingFactor($0000);
private static _ONE := new BlendingFactor($0001);
private static _SRC_COLOR := new BlendingFactor($0300);
private static _ONE_MINUS_SRC_COLOR := new BlendingFactor($0301);
private static _SRC_ALPHA := new BlendingFactor($0302);
private static _ONE_MINUS_SRC_ALPHA := new BlendingFactor($0303);
private static _DST_ALPHA := new BlendingFactor($0304);
private static _ONE_MINUS_DST_ALPHA := new BlendingFactor($0305);
private static _DST_COLOR := new BlendingFactor($0306);
private static _ONE_MINUS_DST_COLOR := new BlendingFactor($0307);
private static _SRC_ALPHA_SATURATE := new BlendingFactor($0308);
private static _CONSTANT_COLOR := new BlendingFactor($8001);
private static _ONE_MINUS_CONSTANT_COLOR := new BlendingFactor($8002);
private static _CONSTANT_ALPHA := new BlendingFactor($8003);
private static _ONE_MINUS_CONSTANT_ALPHA := new BlendingFactor($8004);
private static _SRC1_ALPHA := new BlendingFactor($8589);
private static _SRC1_COLOR := new BlendingFactor($88F9);
private static _ONE_MINUS_SRC1_COLOR := new BlendingFactor($88FA);
private static _ONE_MINUS_SRC1_ALPHA := new BlendingFactor($88FB);
public static property ZERO: BlendingFactor read _ZERO;
public static property ONE: BlendingFactor read _ONE;
public static property SRC_COLOR: BlendingFactor read _SRC_COLOR;
public static property ONE_MINUS_SRC_COLOR: BlendingFactor read _ONE_MINUS_SRC_COLOR;
public static property SRC_ALPHA: BlendingFactor read _SRC_ALPHA;
public static property ONE_MINUS_SRC_ALPHA: BlendingFactor read _ONE_MINUS_SRC_ALPHA;
public static property DST_ALPHA: BlendingFactor read _DST_ALPHA;
public static property ONE_MINUS_DST_ALPHA: BlendingFactor read _ONE_MINUS_DST_ALPHA;
public static property DST_COLOR: BlendingFactor read _DST_COLOR;
public static property ONE_MINUS_DST_COLOR: BlendingFactor read _ONE_MINUS_DST_COLOR;
public static property SRC_ALPHA_SATURATE: BlendingFactor read _SRC_ALPHA_SATURATE;
public static property CONSTANT_COLOR: BlendingFactor read _CONSTANT_COLOR;
public static property ONE_MINUS_CONSTANT_COLOR: BlendingFactor read _ONE_MINUS_CONSTANT_COLOR;
public static property CONSTANT_ALPHA: BlendingFactor read _CONSTANT_ALPHA;
public static property ONE_MINUS_CONSTANT_ALPHA: BlendingFactor read _ONE_MINUS_CONSTANT_ALPHA;
public static property SRC1_ALPHA: BlendingFactor read _SRC1_ALPHA;
public static property SRC1_COLOR: BlendingFactor read _SRC1_COLOR;
public static property ONE_MINUS_SRC1_COLOR: BlendingFactor read _ONE_MINUS_SRC1_COLOR;
public static property ONE_MINUS_SRC1_ALPHA: BlendingFactor read _ONE_MINUS_SRC1_ALPHA;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'ZERO' else
if self.val = UInt32($0001) then Result := 'ONE' else
if self.val = UInt32($0300) then Result := 'SRC_COLOR' else
if self.val = UInt32($0301) then Result := 'ONE_MINUS_SRC_COLOR' else
if self.val = UInt32($0302) then Result := 'SRC_ALPHA' else
if self.val = UInt32($0303) then Result := 'ONE_MINUS_SRC_ALPHA' else
if self.val = UInt32($0304) then Result := 'DST_ALPHA' else
if self.val = UInt32($0305) then Result := 'ONE_MINUS_DST_ALPHA' else
if self.val = UInt32($0306) then Result := 'DST_COLOR' else
if self.val = UInt32($0307) then Result := 'ONE_MINUS_DST_COLOR' else
if self.val = UInt32($0308) then Result := 'SRC_ALPHA_SATURATE' else
if self.val = UInt32($8001) then Result := 'CONSTANT_COLOR' else
if self.val = UInt32($8002) then Result := 'ONE_MINUS_CONSTANT_COLOR' else
if self.val = UInt32($8003) then Result := 'CONSTANT_ALPHA' else
if self.val = UInt32($8004) then Result := 'ONE_MINUS_CONSTANT_ALPHA' else
if self.val = UInt32($8589) then Result := 'SRC1_ALPHA' else
if self.val = UInt32($88F9) then Result := 'SRC1_COLOR' else
if self.val = UInt32($88FA) then Result := 'ONE_MINUS_SRC1_COLOR' else
if self.val = UInt32($88FB) then Result := 'ONE_MINUS_SRC1_ALPHA' else
Result := self.val.ToString;
end;
end;
BlitFramebufferFilter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEAREST := new BlitFramebufferFilter($2600);
private static _LINEAR := new BlitFramebufferFilter($2601);
public static property NEAREST: BlitFramebufferFilter read _NEAREST;
public static property LINEAR: BlitFramebufferFilter read _LINEAR;
public function ToString: string; override;
begin
if self.val = UInt32($2600) then Result := 'NEAREST' else
if self.val = UInt32($2601) then Result := 'LINEAR' else
Result := self.val.ToString;
end;
end;
Buffer = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR := new Buffer($1800);
private static _DEPTH := new Buffer($1801);
private static _STENCIL := new Buffer($1802);
public static property COLOR: Buffer read _COLOR;
public static property DEPTH: Buffer read _DEPTH;
public static property STENCIL: Buffer read _STENCIL;
public function ToString: string; override;
begin
if self.val = UInt32($1800) then Result := 'COLOR' else
if self.val = UInt32($1801) then Result := 'DEPTH' else
if self.val = UInt32($1802) then Result := 'STENCIL' else
Result := self.val.ToString;
end;
end;
BufferStorageMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP_READ_BIT := new BufferStorageMask($0001);
private static _MAP_READ_BIT_EXT := new BufferStorageMask($0001);
private static _MAP_WRITE_BIT := new BufferStorageMask($0002);
private static _MAP_WRITE_BIT_EXT := new BufferStorageMask($0002);
private static _MAP_PERSISTENT_BIT := new BufferStorageMask($0040);
private static _MAP_PERSISTENT_BIT_EXT := new BufferStorageMask($0040);
private static _MAP_COHERENT_BIT := new BufferStorageMask($0080);
private static _MAP_COHERENT_BIT_EXT := new BufferStorageMask($0080);
private static _DYNAMIC_STORAGE_BIT := new BufferStorageMask($0100);
private static _DYNAMIC_STORAGE_BIT_EXT := new BufferStorageMask($0100);
private static _CLIENT_STORAGE_BIT := new BufferStorageMask($0200);
private static _CLIENT_STORAGE_BIT_EXT := new BufferStorageMask($0200);
private static _SPARSE_STORAGE_BIT_ARB := new BufferStorageMask($0400);
private static _LGPU_SEPARATE_STORAGE_BIT_NVX := new BufferStorageMask($0800);
private static _PER_GPU_STORAGE_BIT_NV := new BufferStorageMask($0800);
private static _EXTERNAL_STORAGE_BIT_NVX := new BufferStorageMask($2000);
public static property MAP_READ_BIT: BufferStorageMask read _MAP_READ_BIT;
public static property MAP_READ_BIT_EXT: BufferStorageMask read _MAP_READ_BIT_EXT;
public static property MAP_WRITE_BIT: BufferStorageMask read _MAP_WRITE_BIT;
public static property MAP_WRITE_BIT_EXT: BufferStorageMask read _MAP_WRITE_BIT_EXT;
public static property MAP_PERSISTENT_BIT: BufferStorageMask read _MAP_PERSISTENT_BIT;
public static property MAP_PERSISTENT_BIT_EXT: BufferStorageMask read _MAP_PERSISTENT_BIT_EXT;
public static property MAP_COHERENT_BIT: BufferStorageMask read _MAP_COHERENT_BIT;
public static property MAP_COHERENT_BIT_EXT: BufferStorageMask read _MAP_COHERENT_BIT_EXT;
public static property DYNAMIC_STORAGE_BIT: BufferStorageMask read _DYNAMIC_STORAGE_BIT;
public static property DYNAMIC_STORAGE_BIT_EXT: BufferStorageMask read _DYNAMIC_STORAGE_BIT_EXT;
public static property CLIENT_STORAGE_BIT: BufferStorageMask read _CLIENT_STORAGE_BIT;
public static property CLIENT_STORAGE_BIT_EXT: BufferStorageMask read _CLIENT_STORAGE_BIT_EXT;
public static property SPARSE_STORAGE_BIT_ARB: BufferStorageMask read _SPARSE_STORAGE_BIT_ARB;
public static property LGPU_SEPARATE_STORAGE_BIT_NVX: BufferStorageMask read _LGPU_SEPARATE_STORAGE_BIT_NVX;
public static property PER_GPU_STORAGE_BIT_NV: BufferStorageMask read _PER_GPU_STORAGE_BIT_NV;
public static property EXTERNAL_STORAGE_BIT_NVX: BufferStorageMask read _EXTERNAL_STORAGE_BIT_NVX;
public static function operator or(f1,f2: BufferStorageMask) := new BufferStorageMask(f1.val or f2.val);
public property HAS_FLAG_MAP_READ_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_MAP_READ_BIT_EXT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_MAP_WRITE_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_MAP_WRITE_BIT_EXT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_MAP_PERSISTENT_BIT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_MAP_PERSISTENT_BIT_EXT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_MAP_COHERENT_BIT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_MAP_COHERENT_BIT_EXT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_DYNAMIC_STORAGE_BIT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_DYNAMIC_STORAGE_BIT_EXT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_CLIENT_STORAGE_BIT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_CLIENT_STORAGE_BIT_EXT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_SPARSE_STORAGE_BIT_ARB: boolean read self.val and $0400 <> 0;
public property HAS_FLAG_LGPU_SEPARATE_STORAGE_BIT_NVX: boolean read self.val and $0800 <> 0;
public property HAS_FLAG_PER_GPU_STORAGE_BIT_NV: boolean read self.val and $0800 <> 0;
public property HAS_FLAG_EXTERNAL_STORAGE_BIT_NVX: boolean read self.val and $2000 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'MAP_READ_BIT+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'MAP_READ_BIT_EXT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'MAP_WRITE_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'MAP_WRITE_BIT_EXT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'MAP_PERSISTENT_BIT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'MAP_PERSISTENT_BIT_EXT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'MAP_COHERENT_BIT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'MAP_COHERENT_BIT_EXT+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'DYNAMIC_STORAGE_BIT+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'DYNAMIC_STORAGE_BIT_EXT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'CLIENT_STORAGE_BIT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'CLIENT_STORAGE_BIT_EXT+';
if self.val and UInt32($0400) = UInt32($0400) then res += 'SPARSE_STORAGE_BIT_ARB+';
if self.val and UInt32($0800) = UInt32($0800) then res += 'LGPU_SEPARATE_STORAGE_BIT_NVX+';
if self.val and UInt32($0800) = UInt32($0800) then res += 'PER_GPU_STORAGE_BIT_NV+';
if self.val and UInt32($2000) = UInt32($2000) then res += 'EXTERNAL_STORAGE_BIT_NVX+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
BufferStorageTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ARRAY_BUFFER := new BufferStorageTarget($8892);
private static _ELEMENT_ARRAY_BUFFER := new BufferStorageTarget($8893);
private static _PIXEL_PACK_BUFFER := new BufferStorageTarget($88EB);
private static _PIXEL_UNPACK_BUFFER := new BufferStorageTarget($88EC);
private static _UNIFORM_BUFFER := new BufferStorageTarget($8A11);
private static _TEXTURE_BUFFER := new BufferStorageTarget($8C2A);
private static _TRANSFORM_FEEDBACK_BUFFER := new BufferStorageTarget($8C8E);
private static _COPY_READ_BUFFER := new BufferStorageTarget($8F36);
private static _COPY_WRITE_BUFFER := new BufferStorageTarget($8F37);
private static _DRAW_INDIRECT_BUFFER := new BufferStorageTarget($8F3F);
private static _SHADER_STORAGE_BUFFER := new BufferStorageTarget($90D2);
private static _DISPATCH_INDIRECT_BUFFER := new BufferStorageTarget($90EE);
private static _QUERY_BUFFER := new BufferStorageTarget($9192);
private static _ATOMIC_COUNTER_BUFFER := new BufferStorageTarget($92C0);
public static property ARRAY_BUFFER: BufferStorageTarget read _ARRAY_BUFFER;
public static property ELEMENT_ARRAY_BUFFER: BufferStorageTarget read _ELEMENT_ARRAY_BUFFER;
public static property PIXEL_PACK_BUFFER: BufferStorageTarget read _PIXEL_PACK_BUFFER;
public static property PIXEL_UNPACK_BUFFER: BufferStorageTarget read _PIXEL_UNPACK_BUFFER;
public static property UNIFORM_BUFFER: BufferStorageTarget read _UNIFORM_BUFFER;
public static property TEXTURE_BUFFER: BufferStorageTarget read _TEXTURE_BUFFER;
public static property TRANSFORM_FEEDBACK_BUFFER: BufferStorageTarget read _TRANSFORM_FEEDBACK_BUFFER;
public static property COPY_READ_BUFFER: BufferStorageTarget read _COPY_READ_BUFFER;
public static property COPY_WRITE_BUFFER: BufferStorageTarget read _COPY_WRITE_BUFFER;
public static property DRAW_INDIRECT_BUFFER: BufferStorageTarget read _DRAW_INDIRECT_BUFFER;
public static property SHADER_STORAGE_BUFFER: BufferStorageTarget read _SHADER_STORAGE_BUFFER;
public static property DISPATCH_INDIRECT_BUFFER: BufferStorageTarget read _DISPATCH_INDIRECT_BUFFER;
public static property QUERY_BUFFER: BufferStorageTarget read _QUERY_BUFFER;
public static property ATOMIC_COUNTER_BUFFER: BufferStorageTarget read _ATOMIC_COUNTER_BUFFER;
public function ToString: string; override;
begin
if self.val = UInt32($8892) then Result := 'ARRAY_BUFFER' else
if self.val = UInt32($8893) then Result := 'ELEMENT_ARRAY_BUFFER' else
if self.val = UInt32($88EB) then Result := 'PIXEL_PACK_BUFFER' else
if self.val = UInt32($88EC) then Result := 'PIXEL_UNPACK_BUFFER' else
if self.val = UInt32($8A11) then Result := 'UNIFORM_BUFFER' else
if self.val = UInt32($8C2A) then Result := 'TEXTURE_BUFFER' else
if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
if self.val = UInt32($8F36) then Result := 'COPY_READ_BUFFER' else
if self.val = UInt32($8F37) then Result := 'COPY_WRITE_BUFFER' else
if self.val = UInt32($8F3F) then Result := 'DRAW_INDIRECT_BUFFER' else
if self.val = UInt32($90D2) then Result := 'SHADER_STORAGE_BUFFER' else
if self.val = UInt32($90EE) then Result := 'DISPATCH_INDIRECT_BUFFER' else
if self.val = UInt32($9192) then Result := 'QUERY_BUFFER' else
if self.val = UInt32($92C0) then Result := 'ATOMIC_COUNTER_BUFFER' else
Result := self.val.ToString;
end;
end;
ClearBufferMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DEPTH_BUFFER_BIT := new ClearBufferMask($0100);
private static _ACCUM_BUFFER_BIT := new ClearBufferMask($0200);
private static _STENCIL_BUFFER_BIT := new ClearBufferMask($0400);
private static _COLOR_BUFFER_BIT := new ClearBufferMask($4000);
private static _COVERAGE_BUFFER_BIT_NV := new ClearBufferMask($8000);
public static property DEPTH_BUFFER_BIT: ClearBufferMask read _DEPTH_BUFFER_BIT;
public static property ACCUM_BUFFER_BIT: ClearBufferMask read _ACCUM_BUFFER_BIT;
public static property STENCIL_BUFFER_BIT: ClearBufferMask read _STENCIL_BUFFER_BIT;
public static property COLOR_BUFFER_BIT: ClearBufferMask read _COLOR_BUFFER_BIT;
public static property COVERAGE_BUFFER_BIT_NV: ClearBufferMask read _COVERAGE_BUFFER_BIT_NV;
public static function operator or(f1,f2: ClearBufferMask) := new ClearBufferMask(f1.val or f2.val);
public property HAS_FLAG_DEPTH_BUFFER_BIT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_ACCUM_BUFFER_BIT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_STENCIL_BUFFER_BIT: boolean read self.val and $0400 <> 0;
public property HAS_FLAG_COLOR_BUFFER_BIT: boolean read self.val and $4000 <> 0;
public property HAS_FLAG_COVERAGE_BUFFER_BIT_NV: boolean read self.val and $8000 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0100) = UInt32($0100) then res += 'DEPTH_BUFFER_BIT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'ACCUM_BUFFER_BIT+';
if self.val and UInt32($0400) = UInt32($0400) then res += 'STENCIL_BUFFER_BIT+';
if self.val and UInt32($4000) = UInt32($4000) then res += 'COLOR_BUFFER_BIT+';
if self.val and UInt32($8000) = UInt32($8000) then res += 'COVERAGE_BUFFER_BIT_NV+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
ClientAttribMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CLIENT_PIXEL_STORE_BIT := new ClientAttribMask($0001);
private static _CLIENT_VERTEX_ARRAY_BIT := new ClientAttribMask($0002);
private static _CLIENT_ALL_ATTRIB_BITS := new ClientAttribMask($FFFFFFFF);
public static property CLIENT_PIXEL_STORE_BIT: ClientAttribMask read _CLIENT_PIXEL_STORE_BIT;
public static property CLIENT_VERTEX_ARRAY_BIT: ClientAttribMask read _CLIENT_VERTEX_ARRAY_BIT;
public static property CLIENT_ALL_ATTRIB_BITS: ClientAttribMask read _CLIENT_ALL_ATTRIB_BITS;
public static function operator or(f1,f2: ClientAttribMask) := new ClientAttribMask(f1.val or f2.val);
public property HAS_FLAG_CLIENT_PIXEL_STORE_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_CLIENT_VERTEX_ARRAY_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_CLIENT_ALL_ATTRIB_BITS: boolean read self.val and $FFFFFFFF <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'CLIENT_PIXEL_STORE_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'CLIENT_VERTEX_ARRAY_BIT+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'CLIENT_ALL_ATTRIB_BITS+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
ClipControlDepth = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEGATIVE_ONE_TO_ONE := new ClipControlDepth($935E);
private static _ZERO_TO_ONE := new ClipControlDepth($935F);
public static property NEGATIVE_ONE_TO_ONE: ClipControlDepth read _NEGATIVE_ONE_TO_ONE;
public static property ZERO_TO_ONE: ClipControlDepth read _ZERO_TO_ONE;
public function ToString: string; override;
begin
if self.val = UInt32($935E) then Result := 'NEGATIVE_ONE_TO_ONE' else
if self.val = UInt32($935F) then Result := 'ZERO_TO_ONE' else
Result := self.val.ToString;
end;
end;
ClipControlOrigin = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LOWER_LEFT := new ClipControlOrigin($8CA1);
private static _UPPER_LEFT := new ClipControlOrigin($8CA2);
public static property LOWER_LEFT: ClipControlOrigin read _LOWER_LEFT;
public static property UPPER_LEFT: ClipControlOrigin read _UPPER_LEFT;
public function ToString: string; override;
begin
if self.val = UInt32($8CA1) then Result := 'LOWER_LEFT' else
if self.val = UInt32($8CA2) then Result := 'UPPER_LEFT' else
Result := self.val.ToString;
end;
end;
ClipPlaneName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CLIP_DISTANCE0 := new ClipPlaneName($3000);
private static _CLIP_PLANE0 := new ClipPlaneName($3000);
private static _CLIP_DISTANCE1 := new ClipPlaneName($3001);
private static _CLIP_PLANE1 := new ClipPlaneName($3001);
private static _CLIP_DISTANCE2 := new ClipPlaneName($3002);
private static _CLIP_PLANE2 := new ClipPlaneName($3002);
private static _CLIP_DISTANCE3 := new ClipPlaneName($3003);
private static _CLIP_PLANE3 := new ClipPlaneName($3003);
private static _CLIP_DISTANCE4 := new ClipPlaneName($3004);
private static _CLIP_PLANE4 := new ClipPlaneName($3004);
private static _CLIP_DISTANCE5 := new ClipPlaneName($3005);
private static _CLIP_PLANE5 := new ClipPlaneName($3005);
private static _CLIP_DISTANCE6 := new ClipPlaneName($3006);
private static _CLIP_DISTANCE7 := new ClipPlaneName($3007);
public static property CLIP_DISTANCE0: ClipPlaneName read _CLIP_DISTANCE0;
public static property CLIP_PLANE0: ClipPlaneName read _CLIP_PLANE0;
public static property CLIP_DISTANCE1: ClipPlaneName read _CLIP_DISTANCE1;
public static property CLIP_PLANE1: ClipPlaneName read _CLIP_PLANE1;
public static property CLIP_DISTANCE2: ClipPlaneName read _CLIP_DISTANCE2;
public static property CLIP_PLANE2: ClipPlaneName read _CLIP_PLANE2;
public static property CLIP_DISTANCE3: ClipPlaneName read _CLIP_DISTANCE3;
public static property CLIP_PLANE3: ClipPlaneName read _CLIP_PLANE3;
public static property CLIP_DISTANCE4: ClipPlaneName read _CLIP_DISTANCE4;
public static property CLIP_PLANE4: ClipPlaneName read _CLIP_PLANE4;
public static property CLIP_DISTANCE5: ClipPlaneName read _CLIP_DISTANCE5;
public static property CLIP_PLANE5: ClipPlaneName read _CLIP_PLANE5;
public static property CLIP_DISTANCE6: ClipPlaneName read _CLIP_DISTANCE6;
public static property CLIP_DISTANCE7: ClipPlaneName read _CLIP_DISTANCE7;
public function ToString: string; override;
begin
if self.val = UInt32($3000) then Result := 'CLIP_DISTANCE0' else
if self.val = UInt32($3000) then Result := 'CLIP_PLANE0' else
if self.val = UInt32($3001) then Result := 'CLIP_DISTANCE1' else
if self.val = UInt32($3001) then Result := 'CLIP_PLANE1' else
if self.val = UInt32($3002) then Result := 'CLIP_DISTANCE2' else
if self.val = UInt32($3002) then Result := 'CLIP_PLANE2' else
if self.val = UInt32($3003) then Result := 'CLIP_DISTANCE3' else
if self.val = UInt32($3003) then Result := 'CLIP_PLANE3' else
if self.val = UInt32($3004) then Result := 'CLIP_DISTANCE4' else
if self.val = UInt32($3004) then Result := 'CLIP_PLANE4' else
if self.val = UInt32($3005) then Result := 'CLIP_DISTANCE5' else
if self.val = UInt32($3005) then Result := 'CLIP_PLANE5' else
if self.val = UInt32($3006) then Result := 'CLIP_DISTANCE6' else
if self.val = UInt32($3007) then Result := 'CLIP_DISTANCE7' else
Result := self.val.ToString;
end;
end;
ColorBuffer = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new ColorBuffer($0000);
private static _FRONT_LEFT := new ColorBuffer($0400);
private static _FRONT_RIGHT := new ColorBuffer($0401);
private static _BACK_LEFT := new ColorBuffer($0402);
private static _BACK_RIGHT := new ColorBuffer($0403);
private static _FRONT := new ColorBuffer($0404);
private static _BACK := new ColorBuffer($0405);
private static _LEFT := new ColorBuffer($0406);
private static _RIGHT := new ColorBuffer($0407);
private static _FRONT_AND_BACK := new ColorBuffer($0408);
private static _COLOR_ATTACHMENT0 := new ColorBuffer($8CE0);
private static _COLOR_ATTACHMENT1 := new ColorBuffer($8CE1);
private static _COLOR_ATTACHMENT2 := new ColorBuffer($8CE2);
private static _COLOR_ATTACHMENT3 := new ColorBuffer($8CE3);
private static _COLOR_ATTACHMENT4 := new ColorBuffer($8CE4);
private static _COLOR_ATTACHMENT5 := new ColorBuffer($8CE5);
private static _COLOR_ATTACHMENT6 := new ColorBuffer($8CE6);
private static _COLOR_ATTACHMENT7 := new ColorBuffer($8CE7);
private static _COLOR_ATTACHMENT8 := new ColorBuffer($8CE8);
private static _COLOR_ATTACHMENT9 := new ColorBuffer($8CE9);
private static _COLOR_ATTACHMENT10 := new ColorBuffer($8CEA);
private static _COLOR_ATTACHMENT11 := new ColorBuffer($8CEB);
private static _COLOR_ATTACHMENT12 := new ColorBuffer($8CEC);
private static _COLOR_ATTACHMENT13 := new ColorBuffer($8CED);
private static _COLOR_ATTACHMENT14 := new ColorBuffer($8CEE);
private static _COLOR_ATTACHMENT15 := new ColorBuffer($8CEF);
private static _COLOR_ATTACHMENT16 := new ColorBuffer($8CF0);
private static _COLOR_ATTACHMENT17 := new ColorBuffer($8CF1);
private static _COLOR_ATTACHMENT18 := new ColorBuffer($8CF2);
private static _COLOR_ATTACHMENT19 := new ColorBuffer($8CF3);
private static _COLOR_ATTACHMENT20 := new ColorBuffer($8CF4);
private static _COLOR_ATTACHMENT21 := new ColorBuffer($8CF5);
private static _COLOR_ATTACHMENT22 := new ColorBuffer($8CF6);
private static _COLOR_ATTACHMENT23 := new ColorBuffer($8CF7);
private static _COLOR_ATTACHMENT24 := new ColorBuffer($8CF8);
private static _COLOR_ATTACHMENT25 := new ColorBuffer($8CF9);
private static _COLOR_ATTACHMENT26 := new ColorBuffer($8CFA);
private static _COLOR_ATTACHMENT27 := new ColorBuffer($8CFB);
private static _COLOR_ATTACHMENT28 := new ColorBuffer($8CFC);
private static _COLOR_ATTACHMENT29 := new ColorBuffer($8CFD);
private static _COLOR_ATTACHMENT30 := new ColorBuffer($8CFE);
private static _COLOR_ATTACHMENT31 := new ColorBuffer($8CFF);
public static property NONE: ColorBuffer read _NONE;
public static property FRONT_LEFT: ColorBuffer read _FRONT_LEFT;
public static property FRONT_RIGHT: ColorBuffer read _FRONT_RIGHT;
public static property BACK_LEFT: ColorBuffer read _BACK_LEFT;
public static property BACK_RIGHT: ColorBuffer read _BACK_RIGHT;
public static property FRONT: ColorBuffer read _FRONT;
public static property BACK: ColorBuffer read _BACK;
public static property LEFT: ColorBuffer read _LEFT;
public static property RIGHT: ColorBuffer read _RIGHT;
public static property FRONT_AND_BACK: ColorBuffer read _FRONT_AND_BACK;
public static property COLOR_ATTACHMENT0: ColorBuffer read _COLOR_ATTACHMENT0;
public static property COLOR_ATTACHMENT1: ColorBuffer read _COLOR_ATTACHMENT1;
public static property COLOR_ATTACHMENT2: ColorBuffer read _COLOR_ATTACHMENT2;
public static property COLOR_ATTACHMENT3: ColorBuffer read _COLOR_ATTACHMENT3;
public static property COLOR_ATTACHMENT4: ColorBuffer read _COLOR_ATTACHMENT4;
public static property COLOR_ATTACHMENT5: ColorBuffer read _COLOR_ATTACHMENT5;
public static property COLOR_ATTACHMENT6: ColorBuffer read _COLOR_ATTACHMENT6;
public static property COLOR_ATTACHMENT7: ColorBuffer read _COLOR_ATTACHMENT7;
public static property COLOR_ATTACHMENT8: ColorBuffer read _COLOR_ATTACHMENT8;
public static property COLOR_ATTACHMENT9: ColorBuffer read _COLOR_ATTACHMENT9;
public static property COLOR_ATTACHMENT10: ColorBuffer read _COLOR_ATTACHMENT10;
public static property COLOR_ATTACHMENT11: ColorBuffer read _COLOR_ATTACHMENT11;
public static property COLOR_ATTACHMENT12: ColorBuffer read _COLOR_ATTACHMENT12;
public static property COLOR_ATTACHMENT13: ColorBuffer read _COLOR_ATTACHMENT13;
public static property COLOR_ATTACHMENT14: ColorBuffer read _COLOR_ATTACHMENT14;
public static property COLOR_ATTACHMENT15: ColorBuffer read _COLOR_ATTACHMENT15;
public static property COLOR_ATTACHMENT16: ColorBuffer read _COLOR_ATTACHMENT16;
public static property COLOR_ATTACHMENT17: ColorBuffer read _COLOR_ATTACHMENT17;
public static property COLOR_ATTACHMENT18: ColorBuffer read _COLOR_ATTACHMENT18;
public static property COLOR_ATTACHMENT19: ColorBuffer read _COLOR_ATTACHMENT19;
public static property COLOR_ATTACHMENT20: ColorBuffer read _COLOR_ATTACHMENT20;
public static property COLOR_ATTACHMENT21: ColorBuffer read _COLOR_ATTACHMENT21;
public static property COLOR_ATTACHMENT22: ColorBuffer read _COLOR_ATTACHMENT22;
public static property COLOR_ATTACHMENT23: ColorBuffer read _COLOR_ATTACHMENT23;
public static property COLOR_ATTACHMENT24: ColorBuffer read _COLOR_ATTACHMENT24;
public static property COLOR_ATTACHMENT25: ColorBuffer read _COLOR_ATTACHMENT25;
public static property COLOR_ATTACHMENT26: ColorBuffer read _COLOR_ATTACHMENT26;
public static property COLOR_ATTACHMENT27: ColorBuffer read _COLOR_ATTACHMENT27;
public static property COLOR_ATTACHMENT28: ColorBuffer read _COLOR_ATTACHMENT28;
public static property COLOR_ATTACHMENT29: ColorBuffer read _COLOR_ATTACHMENT29;
public static property COLOR_ATTACHMENT30: ColorBuffer read _COLOR_ATTACHMENT30;
public static property COLOR_ATTACHMENT31: ColorBuffer read _COLOR_ATTACHMENT31;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($0400) then Result := 'FRONT_LEFT' else
if self.val = UInt32($0401) then Result := 'FRONT_RIGHT' else
if self.val = UInt32($0402) then Result := 'BACK_LEFT' else
if self.val = UInt32($0403) then Result := 'BACK_RIGHT' else
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0406) then Result := 'LEFT' else
if self.val = UInt32($0407) then Result := 'RIGHT' else
if self.val = UInt32($0408) then Result := 'FRONT_AND_BACK' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15' else
if self.val = UInt32($8CF0) then Result := 'COLOR_ATTACHMENT16' else
if self.val = UInt32($8CF1) then Result := 'COLOR_ATTACHMENT17' else
if self.val = UInt32($8CF2) then Result := 'COLOR_ATTACHMENT18' else
if self.val = UInt32($8CF3) then Result := 'COLOR_ATTACHMENT19' else
if self.val = UInt32($8CF4) then Result := 'COLOR_ATTACHMENT20' else
if self.val = UInt32($8CF5) then Result := 'COLOR_ATTACHMENT21' else
if self.val = UInt32($8CF6) then Result := 'COLOR_ATTACHMENT22' else
if self.val = UInt32($8CF7) then Result := 'COLOR_ATTACHMENT23' else
if self.val = UInt32($8CF8) then Result := 'COLOR_ATTACHMENT24' else
if self.val = UInt32($8CF9) then Result := 'COLOR_ATTACHMENT25' else
if self.val = UInt32($8CFA) then Result := 'COLOR_ATTACHMENT26' else
if self.val = UInt32($8CFB) then Result := 'COLOR_ATTACHMENT27' else
if self.val = UInt32($8CFC) then Result := 'COLOR_ATTACHMENT28' else
if self.val = UInt32($8CFD) then Result := 'COLOR_ATTACHMENT29' else
if self.val = UInt32($8CFE) then Result := 'COLOR_ATTACHMENT30' else
if self.val = UInt32($8CFF) then Result := 'COLOR_ATTACHMENT31' else
Result := self.val.ToString;
end;
end;
ColorMaterialParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _AMBIENT := new ColorMaterialParameter($1200);
private static _DIFFUSE := new ColorMaterialParameter($1201);
private static _SPECULAR := new ColorMaterialParameter($1202);
private static _EMISSION := new ColorMaterialParameter($1600);
private static _AMBIENT_AND_DIFFUSE := new ColorMaterialParameter($1602);
public static property AMBIENT: ColorMaterialParameter read _AMBIENT;
public static property DIFFUSE: ColorMaterialParameter read _DIFFUSE;
public static property SPECULAR: ColorMaterialParameter read _SPECULAR;
public static property EMISSION: ColorMaterialParameter read _EMISSION;
public static property AMBIENT_AND_DIFFUSE: ColorMaterialParameter read _AMBIENT_AND_DIFFUSE;
public function ToString: string; override;
begin
if self.val = UInt32($1200) then Result := 'AMBIENT' else
if self.val = UInt32($1201) then Result := 'DIFFUSE' else
if self.val = UInt32($1202) then Result := 'SPECULAR' else
if self.val = UInt32($1600) then Result := 'EMISSION' else
if self.val = UInt32($1602) then Result := 'AMBIENT_AND_DIFFUSE' else
Result := self.val.ToString;
end;
end;
ColorPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new ColorPointerType($1400);
private static _UNSIGNED_BYTE := new ColorPointerType($1401);
private static _UNSIGNED_SHORT := new ColorPointerType($1403);
private static _UNSIGNED_INT := new ColorPointerType($1405);
public static property BYTE: ColorPointerType read _BYTE;
public static property UNSIGNED_BYTE: ColorPointerType read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: ColorPointerType read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: ColorPointerType read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
ColorTableTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR_TABLE := new ColorTableTarget($80D0);
private static _POST_CONVOLUTION_COLOR_TABLE := new ColorTableTarget($80D1);
private static _POST_COLOR_MATRIX_COLOR_TABLE := new ColorTableTarget($80D2);
public static property COLOR_TABLE: ColorTableTarget read _COLOR_TABLE;
public static property POST_CONVOLUTION_COLOR_TABLE: ColorTableTarget read _POST_CONVOLUTION_COLOR_TABLE;
public static property POST_COLOR_MATRIX_COLOR_TABLE: ColorTableTarget read _POST_COLOR_MATRIX_COLOR_TABLE;
public function ToString: string; override;
begin
if self.val = UInt32($80D0) then Result := 'COLOR_TABLE' else
if self.val = UInt32($80D1) then Result := 'POST_CONVOLUTION_COLOR_TABLE' else
if self.val = UInt32($80D2) then Result := 'POST_COLOR_MATRIX_COLOR_TABLE' else
Result := self.val.ToString;
end;
end;
ConditionalRenderMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _QUERY_WAIT := new ConditionalRenderMode($8E13);
private static _QUERY_NO_WAIT := new ConditionalRenderMode($8E14);
private static _QUERY_BY_REGION_WAIT := new ConditionalRenderMode($8E15);
private static _QUERY_BY_REGION_NO_WAIT := new ConditionalRenderMode($8E16);
private static _QUERY_WAIT_INVERTED := new ConditionalRenderMode($8E17);
private static _QUERY_NO_WAIT_INVERTED := new ConditionalRenderMode($8E18);
private static _QUERY_BY_REGION_WAIT_INVERTED := new ConditionalRenderMode($8E19);
private static _QUERY_BY_REGION_NO_WAIT_INVERTED := new ConditionalRenderMode($8E1A);
public static property QUERY_WAIT: ConditionalRenderMode read _QUERY_WAIT;
public static property QUERY_NO_WAIT: ConditionalRenderMode read _QUERY_NO_WAIT;
public static property QUERY_BY_REGION_WAIT: ConditionalRenderMode read _QUERY_BY_REGION_WAIT;
public static property QUERY_BY_REGION_NO_WAIT: ConditionalRenderMode read _QUERY_BY_REGION_NO_WAIT;
public static property QUERY_WAIT_INVERTED: ConditionalRenderMode read _QUERY_WAIT_INVERTED;
public static property QUERY_NO_WAIT_INVERTED: ConditionalRenderMode read _QUERY_NO_WAIT_INVERTED;
public static property QUERY_BY_REGION_WAIT_INVERTED: ConditionalRenderMode read _QUERY_BY_REGION_WAIT_INVERTED;
public static property QUERY_BY_REGION_NO_WAIT_INVERTED: ConditionalRenderMode read _QUERY_BY_REGION_NO_WAIT_INVERTED;
public function ToString: string; override;
begin
if self.val = UInt32($8E13) then Result := 'QUERY_WAIT' else
if self.val = UInt32($8E14) then Result := 'QUERY_NO_WAIT' else
if self.val = UInt32($8E15) then Result := 'QUERY_BY_REGION_WAIT' else
if self.val = UInt32($8E16) then Result := 'QUERY_BY_REGION_NO_WAIT' else
if self.val = UInt32($8E17) then Result := 'QUERY_WAIT_INVERTED' else
if self.val = UInt32($8E18) then Result := 'QUERY_NO_WAIT_INVERTED' else
if self.val = UInt32($8E19) then Result := 'QUERY_BY_REGION_WAIT_INVERTED' else
if self.val = UInt32($8E1A) then Result := 'QUERY_BY_REGION_NO_WAIT_INVERTED' else
Result := self.val.ToString;
end;
end;
ConvolutionTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CONVOLUTION_1D := new ConvolutionTarget($8010);
private static _CONVOLUTION_2D := new ConvolutionTarget($8011);
public static property CONVOLUTION_1D: ConvolutionTarget read _CONVOLUTION_1D;
public static property CONVOLUTION_2D: ConvolutionTarget read _CONVOLUTION_2D;
public function ToString: string; override;
begin
if self.val = UInt32($8010) then Result := 'CONVOLUTION_1D' else
if self.val = UInt32($8011) then Result := 'CONVOLUTION_2D' else
Result := self.val.ToString;
end;
end;
CopyBufferSubDataTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ARRAY_BUFFER := new CopyBufferSubDataTarget($8892);
private static _ELEMENT_ARRAY_BUFFER := new CopyBufferSubDataTarget($8893);
private static _PIXEL_PACK_BUFFER := new CopyBufferSubDataTarget($88EB);
private static _PIXEL_UNPACK_BUFFER := new CopyBufferSubDataTarget($88EC);
private static _UNIFORM_BUFFER := new CopyBufferSubDataTarget($8A11);
private static _TEXTURE_BUFFER := new CopyBufferSubDataTarget($8C2A);
private static _TRANSFORM_FEEDBACK_BUFFER := new CopyBufferSubDataTarget($8C8E);
private static _COPY_READ_BUFFER := new CopyBufferSubDataTarget($8F36);
private static _COPY_WRITE_BUFFER := new CopyBufferSubDataTarget($8F37);
private static _DRAW_INDIRECT_BUFFER := new CopyBufferSubDataTarget($8F3F);
private static _SHADER_STORAGE_BUFFER := new CopyBufferSubDataTarget($90D2);
private static _DISPATCH_INDIRECT_BUFFER := new CopyBufferSubDataTarget($90EE);
private static _QUERY_BUFFER := new CopyBufferSubDataTarget($9192);
private static _ATOMIC_COUNTER_BUFFER := new CopyBufferSubDataTarget($92C0);
public static property ARRAY_BUFFER: CopyBufferSubDataTarget read _ARRAY_BUFFER;
public static property ELEMENT_ARRAY_BUFFER: CopyBufferSubDataTarget read _ELEMENT_ARRAY_BUFFER;
public static property PIXEL_PACK_BUFFER: CopyBufferSubDataTarget read _PIXEL_PACK_BUFFER;
public static property PIXEL_UNPACK_BUFFER: CopyBufferSubDataTarget read _PIXEL_UNPACK_BUFFER;
public static property UNIFORM_BUFFER: CopyBufferSubDataTarget read _UNIFORM_BUFFER;
public static property TEXTURE_BUFFER: CopyBufferSubDataTarget read _TEXTURE_BUFFER;
public static property TRANSFORM_FEEDBACK_BUFFER: CopyBufferSubDataTarget read _TRANSFORM_FEEDBACK_BUFFER;
public static property COPY_READ_BUFFER: CopyBufferSubDataTarget read _COPY_READ_BUFFER;
public static property COPY_WRITE_BUFFER: CopyBufferSubDataTarget read _COPY_WRITE_BUFFER;
public static property DRAW_INDIRECT_BUFFER: CopyBufferSubDataTarget read _DRAW_INDIRECT_BUFFER;
public static property SHADER_STORAGE_BUFFER: CopyBufferSubDataTarget read _SHADER_STORAGE_BUFFER;
public static property DISPATCH_INDIRECT_BUFFER: CopyBufferSubDataTarget read _DISPATCH_INDIRECT_BUFFER;
public static property QUERY_BUFFER: CopyBufferSubDataTarget read _QUERY_BUFFER;
public static property ATOMIC_COUNTER_BUFFER: CopyBufferSubDataTarget read _ATOMIC_COUNTER_BUFFER;
public function ToString: string; override;
begin
if self.val = UInt32($8892) then Result := 'ARRAY_BUFFER' else
if self.val = UInt32($8893) then Result := 'ELEMENT_ARRAY_BUFFER' else
if self.val = UInt32($88EB) then Result := 'PIXEL_PACK_BUFFER' else
if self.val = UInt32($88EC) then Result := 'PIXEL_UNPACK_BUFFER' else
if self.val = UInt32($8A11) then Result := 'UNIFORM_BUFFER' else
if self.val = UInt32($8C2A) then Result := 'TEXTURE_BUFFER' else
if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
if self.val = UInt32($8F36) then Result := 'COPY_READ_BUFFER' else
if self.val = UInt32($8F37) then Result := 'COPY_WRITE_BUFFER' else
if self.val = UInt32($8F3F) then Result := 'DRAW_INDIRECT_BUFFER' else
if self.val = UInt32($90D2) then Result := 'SHADER_STORAGE_BUFFER' else
if self.val = UInt32($90EE) then Result := 'DISPATCH_INDIRECT_BUFFER' else
if self.val = UInt32($9192) then Result := 'QUERY_BUFFER' else
if self.val = UInt32($92C0) then Result := 'ATOMIC_COUNTER_BUFFER' else
Result := self.val.ToString;
end;
end;
CopyImageSubDataTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_1D := new CopyImageSubDataTarget($0DE0);
private static _TEXTURE_2D := new CopyImageSubDataTarget($0DE1);
private static _TEXTURE_3D := new CopyImageSubDataTarget($806F);
private static _TEXTURE_RECTANGLE := new CopyImageSubDataTarget($84F5);
private static _TEXTURE_CUBE_MAP := new CopyImageSubDataTarget($8513);
private static _TEXTURE_1D_ARRAY := new CopyImageSubDataTarget($8C18);
private static _TEXTURE_2D_ARRAY := new CopyImageSubDataTarget($8C1A);
private static _RENDERBUFFER := new CopyImageSubDataTarget($8D41);
private static _TEXTURE_CUBE_MAP_ARRAY := new CopyImageSubDataTarget($9009);
private static _TEXTURE_2D_MULTISAMPLE := new CopyImageSubDataTarget($9100);
private static _TEXTURE_2D_MULTISAMPLE_ARRAY := new CopyImageSubDataTarget($9102);
public static property TEXTURE_1D: CopyImageSubDataTarget read _TEXTURE_1D;
public static property TEXTURE_2D: CopyImageSubDataTarget read _TEXTURE_2D;
public static property TEXTURE_3D: CopyImageSubDataTarget read _TEXTURE_3D;
public static property TEXTURE_RECTANGLE: CopyImageSubDataTarget read _TEXTURE_RECTANGLE;
public static property TEXTURE_CUBE_MAP: CopyImageSubDataTarget read _TEXTURE_CUBE_MAP;
public static property TEXTURE_1D_ARRAY: CopyImageSubDataTarget read _TEXTURE_1D_ARRAY;
public static property TEXTURE_2D_ARRAY: CopyImageSubDataTarget read _TEXTURE_2D_ARRAY;
public static property RENDERBUFFER: CopyImageSubDataTarget read _RENDERBUFFER;
public static property TEXTURE_CUBE_MAP_ARRAY: CopyImageSubDataTarget read _TEXTURE_CUBE_MAP_ARRAY;
public static property TEXTURE_2D_MULTISAMPLE: CopyImageSubDataTarget read _TEXTURE_2D_MULTISAMPLE;
public static property TEXTURE_2D_MULTISAMPLE_ARRAY: CopyImageSubDataTarget read _TEXTURE_2D_MULTISAMPLE_ARRAY;
public function ToString: string; override;
begin
if self.val = UInt32($0DE0) then Result := 'TEXTURE_1D' else
if self.val = UInt32($0DE1) then Result := 'TEXTURE_2D' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D' else
if self.val = UInt32($84F5) then Result := 'TEXTURE_RECTANGLE' else
if self.val = UInt32($8513) then Result := 'TEXTURE_CUBE_MAP' else
if self.val = UInt32($8C18) then Result := 'TEXTURE_1D_ARRAY' else
if self.val = UInt32($8C1A) then Result := 'TEXTURE_2D_ARRAY' else
if self.val = UInt32($8D41) then Result := 'RENDERBUFFER' else
if self.val = UInt32($9009) then Result := 'TEXTURE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9100) then Result := 'TEXTURE_2D_MULTISAMPLE' else
if self.val = UInt32($9102) then Result := 'TEXTURE_2D_MULTISAMPLE_ARRAY' else
Result := self.val.ToString;
end;
end;
CullFaceMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRONT := new CullFaceMode($0404);
private static _BACK := new CullFaceMode($0405);
private static _FRONT_AND_BACK := new CullFaceMode($0408);
public static property FRONT: CullFaceMode read _FRONT;
public static property BACK: CullFaceMode read _BACK;
public static property FRONT_AND_BACK: CullFaceMode read _FRONT_AND_BACK;
public function ToString: string; override;
begin
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0408) then Result := 'FRONT_AND_BACK' else
Result := self.val.ToString;
end;
end;
DebugSeverity = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DONT_CARE := new DebugSeverity($1100);
private static _DEBUG_SEVERITY_NOTIFICATION := new DebugSeverity($826B);
private static _DEBUG_SEVERITY_HIGH := new DebugSeverity($9146);
private static _DEBUG_SEVERITY_MEDIUM := new DebugSeverity($9147);
private static _DEBUG_SEVERITY_LOW := new DebugSeverity($9148);
public static property DONT_CARE: DebugSeverity read _DONT_CARE;
public static property DEBUG_SEVERITY_NOTIFICATION: DebugSeverity read _DEBUG_SEVERITY_NOTIFICATION;
public static property DEBUG_SEVERITY_HIGH: DebugSeverity read _DEBUG_SEVERITY_HIGH;
public static property DEBUG_SEVERITY_MEDIUM: DebugSeverity read _DEBUG_SEVERITY_MEDIUM;
public static property DEBUG_SEVERITY_LOW: DebugSeverity read _DEBUG_SEVERITY_LOW;
public function ToString: string; override;
begin
if self.val = UInt32($1100) then Result := 'DONT_CARE' else
if self.val = UInt32($826B) then Result := 'DEBUG_SEVERITY_NOTIFICATION' else
if self.val = UInt32($9146) then Result := 'DEBUG_SEVERITY_HIGH' else
if self.val = UInt32($9147) then Result := 'DEBUG_SEVERITY_MEDIUM' else
if self.val = UInt32($9148) then Result := 'DEBUG_SEVERITY_LOW' else
Result := self.val.ToString;
end;
end;
DebugSource = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DONT_CARE := new DebugSource($1100);
private static _DEBUG_SOURCE_API := new DebugSource($8246);
private static _DEBUG_SOURCE_WINDOW_SYSTEM := new DebugSource($8247);
private static _DEBUG_SOURCE_SHADER_COMPILER := new DebugSource($8248);
private static _DEBUG_SOURCE_THIRD_PARTY := new DebugSource($8249);
private static _DEBUG_SOURCE_APPLICATION := new DebugSource($824A);
private static _DEBUG_SOURCE_OTHER := new DebugSource($824B);
public static property DONT_CARE: DebugSource read _DONT_CARE;
public static property DEBUG_SOURCE_API: DebugSource read _DEBUG_SOURCE_API;
public static property DEBUG_SOURCE_WINDOW_SYSTEM: DebugSource read _DEBUG_SOURCE_WINDOW_SYSTEM;
public static property DEBUG_SOURCE_SHADER_COMPILER: DebugSource read _DEBUG_SOURCE_SHADER_COMPILER;
public static property DEBUG_SOURCE_THIRD_PARTY: DebugSource read _DEBUG_SOURCE_THIRD_PARTY;
public static property DEBUG_SOURCE_APPLICATION: DebugSource read _DEBUG_SOURCE_APPLICATION;
public static property DEBUG_SOURCE_OTHER: DebugSource read _DEBUG_SOURCE_OTHER;
public function ToString: string; override;
begin
if self.val = UInt32($1100) then Result := 'DONT_CARE' else
if self.val = UInt32($8246) then Result := 'DEBUG_SOURCE_API' else
if self.val = UInt32($8247) then Result := 'DEBUG_SOURCE_WINDOW_SYSTEM' else
if self.val = UInt32($8248) then Result := 'DEBUG_SOURCE_SHADER_COMPILER' else
if self.val = UInt32($8249) then Result := 'DEBUG_SOURCE_THIRD_PARTY' else
if self.val = UInt32($824A) then Result := 'DEBUG_SOURCE_APPLICATION' else
if self.val = UInt32($824B) then Result := 'DEBUG_SOURCE_OTHER' else
Result := self.val.ToString;
end;
end;
DebugType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DONT_CARE := new DebugType($1100);
private static _DEBUG_TYPE_ERROR := new DebugType($824C);
private static _DEBUG_TYPE_DEPRECATED_BEHAVIOR := new DebugType($824D);
private static _DEBUG_TYPE_UNDEFINED_BEHAVIOR := new DebugType($824E);
private static _DEBUG_TYPE_PORTABILITY := new DebugType($824F);
private static _DEBUG_TYPE_PERFORMANCE := new DebugType($8250);
private static _DEBUG_TYPE_OTHER := new DebugType($8251);
private static _DEBUG_TYPE_MARKER := new DebugType($8268);
private static _DEBUG_TYPE_PUSH_GROUP := new DebugType($8269);
private static _DEBUG_TYPE_POP_GROUP := new DebugType($826A);
public static property DONT_CARE: DebugType read _DONT_CARE;
public static property DEBUG_TYPE_ERROR: DebugType read _DEBUG_TYPE_ERROR;
public static property DEBUG_TYPE_DEPRECATED_BEHAVIOR: DebugType read _DEBUG_TYPE_DEPRECATED_BEHAVIOR;
public static property DEBUG_TYPE_UNDEFINED_BEHAVIOR: DebugType read _DEBUG_TYPE_UNDEFINED_BEHAVIOR;
public static property DEBUG_TYPE_PORTABILITY: DebugType read _DEBUG_TYPE_PORTABILITY;
public static property DEBUG_TYPE_PERFORMANCE: DebugType read _DEBUG_TYPE_PERFORMANCE;
public static property DEBUG_TYPE_OTHER: DebugType read _DEBUG_TYPE_OTHER;
public static property DEBUG_TYPE_MARKER: DebugType read _DEBUG_TYPE_MARKER;
public static property DEBUG_TYPE_PUSH_GROUP: DebugType read _DEBUG_TYPE_PUSH_GROUP;
public static property DEBUG_TYPE_POP_GROUP: DebugType read _DEBUG_TYPE_POP_GROUP;
public function ToString: string; override;
begin
if self.val = UInt32($1100) then Result := 'DONT_CARE' else
if self.val = UInt32($824C) then Result := 'DEBUG_TYPE_ERROR' else
if self.val = UInt32($824D) then Result := 'DEBUG_TYPE_DEPRECATED_BEHAVIOR' else
if self.val = UInt32($824E) then Result := 'DEBUG_TYPE_UNDEFINED_BEHAVIOR' else
if self.val = UInt32($824F) then Result := 'DEBUG_TYPE_PORTABILITY' else
if self.val = UInt32($8250) then Result := 'DEBUG_TYPE_PERFORMANCE' else
if self.val = UInt32($8251) then Result := 'DEBUG_TYPE_OTHER' else
if self.val = UInt32($8268) then Result := 'DEBUG_TYPE_MARKER' else
if self.val = UInt32($8269) then Result := 'DEBUG_TYPE_PUSH_GROUP' else
if self.val = UInt32($826A) then Result := 'DEBUG_TYPE_POP_GROUP' else
Result := self.val.ToString;
end;
end;
DepthFunction = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEVER := new DepthFunction($0200);
private static _LESS := new DepthFunction($0201);
private static _EQUAL := new DepthFunction($0202);
private static _LEQUAL := new DepthFunction($0203);
private static _GREATER := new DepthFunction($0204);
private static _NOTEQUAL := new DepthFunction($0205);
private static _GEQUAL := new DepthFunction($0206);
private static _ALWAYS := new DepthFunction($0207);
public static property NEVER: DepthFunction read _NEVER;
public static property LESS: DepthFunction read _LESS;
public static property EQUAL: DepthFunction read _EQUAL;
public static property LEQUAL: DepthFunction read _LEQUAL;
public static property GREATER: DepthFunction read _GREATER;
public static property NOTEQUAL: DepthFunction read _NOTEQUAL;
public static property GEQUAL: DepthFunction read _GEQUAL;
public static property ALWAYS: DepthFunction read _ALWAYS;
public function ToString: string; override;
begin
if self.val = UInt32($0200) then Result := 'NEVER' else
if self.val = UInt32($0201) then Result := 'LESS' else
if self.val = UInt32($0202) then Result := 'EQUAL' else
if self.val = UInt32($0203) then Result := 'LEQUAL' else
if self.val = UInt32($0204) then Result := 'GREATER' else
if self.val = UInt32($0205) then Result := 'NOTEQUAL' else
if self.val = UInt32($0206) then Result := 'GEQUAL' else
if self.val = UInt32($0207) then Result := 'ALWAYS' else
Result := self.val.ToString;
end;
end;
DrawBufferMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new DrawBufferMode($0000);
private static _NONE_OES := new DrawBufferMode($0000);
private static _FRONT_LEFT := new DrawBufferMode($0400);
private static _FRONT_RIGHT := new DrawBufferMode($0401);
private static _BACK_LEFT := new DrawBufferMode($0402);
private static _BACK_RIGHT := new DrawBufferMode($0403);
private static _FRONT := new DrawBufferMode($0404);
private static _BACK := new DrawBufferMode($0405);
private static _LEFT := new DrawBufferMode($0406);
private static _RIGHT := new DrawBufferMode($0407);
private static _FRONT_AND_BACK := new DrawBufferMode($0408);
private static _AUX0 := new DrawBufferMode($0409);
private static _AUX1 := new DrawBufferMode($040A);
private static _AUX2 := new DrawBufferMode($040B);
private static _AUX3 := new DrawBufferMode($040C);
private static _COLOR_ATTACHMENT0 := new DrawBufferMode($8CE0);
private static _COLOR_ATTACHMENT1 := new DrawBufferMode($8CE1);
private static _COLOR_ATTACHMENT2 := new DrawBufferMode($8CE2);
private static _COLOR_ATTACHMENT3 := new DrawBufferMode($8CE3);
private static _COLOR_ATTACHMENT4 := new DrawBufferMode($8CE4);
private static _COLOR_ATTACHMENT5 := new DrawBufferMode($8CE5);
private static _COLOR_ATTACHMENT6 := new DrawBufferMode($8CE6);
private static _COLOR_ATTACHMENT7 := new DrawBufferMode($8CE7);
private static _COLOR_ATTACHMENT8 := new DrawBufferMode($8CE8);
private static _COLOR_ATTACHMENT9 := new DrawBufferMode($8CE9);
private static _COLOR_ATTACHMENT10 := new DrawBufferMode($8CEA);
private static _COLOR_ATTACHMENT11 := new DrawBufferMode($8CEB);
private static _COLOR_ATTACHMENT12 := new DrawBufferMode($8CEC);
private static _COLOR_ATTACHMENT13 := new DrawBufferMode($8CED);
private static _COLOR_ATTACHMENT14 := new DrawBufferMode($8CEE);
private static _COLOR_ATTACHMENT15 := new DrawBufferMode($8CEF);
private static _COLOR_ATTACHMENT16 := new DrawBufferMode($8CF0);
private static _COLOR_ATTACHMENT17 := new DrawBufferMode($8CF1);
private static _COLOR_ATTACHMENT18 := new DrawBufferMode($8CF2);
private static _COLOR_ATTACHMENT19 := new DrawBufferMode($8CF3);
private static _COLOR_ATTACHMENT20 := new DrawBufferMode($8CF4);
private static _COLOR_ATTACHMENT21 := new DrawBufferMode($8CF5);
private static _COLOR_ATTACHMENT22 := new DrawBufferMode($8CF6);
private static _COLOR_ATTACHMENT23 := new DrawBufferMode($8CF7);
private static _COLOR_ATTACHMENT24 := new DrawBufferMode($8CF8);
private static _COLOR_ATTACHMENT25 := new DrawBufferMode($8CF9);
private static _COLOR_ATTACHMENT26 := new DrawBufferMode($8CFA);
private static _COLOR_ATTACHMENT27 := new DrawBufferMode($8CFB);
private static _COLOR_ATTACHMENT28 := new DrawBufferMode($8CFC);
private static _COLOR_ATTACHMENT29 := new DrawBufferMode($8CFD);
private static _COLOR_ATTACHMENT30 := new DrawBufferMode($8CFE);
private static _COLOR_ATTACHMENT31 := new DrawBufferMode($8CFF);
public static property NONE: DrawBufferMode read _NONE;
public static property NONE_OES: DrawBufferMode read _NONE_OES;
public static property FRONT_LEFT: DrawBufferMode read _FRONT_LEFT;
public static property FRONT_RIGHT: DrawBufferMode read _FRONT_RIGHT;
public static property BACK_LEFT: DrawBufferMode read _BACK_LEFT;
public static property BACK_RIGHT: DrawBufferMode read _BACK_RIGHT;
public static property FRONT: DrawBufferMode read _FRONT;
public static property BACK: DrawBufferMode read _BACK;
public static property LEFT: DrawBufferMode read _LEFT;
public static property RIGHT: DrawBufferMode read _RIGHT;
public static property FRONT_AND_BACK: DrawBufferMode read _FRONT_AND_BACK;
public static property AUX0: DrawBufferMode read _AUX0;
public static property AUX1: DrawBufferMode read _AUX1;
public static property AUX2: DrawBufferMode read _AUX2;
public static property AUX3: DrawBufferMode read _AUX3;
public static property COLOR_ATTACHMENT0: DrawBufferMode read _COLOR_ATTACHMENT0;
public static property COLOR_ATTACHMENT1: DrawBufferMode read _COLOR_ATTACHMENT1;
public static property COLOR_ATTACHMENT2: DrawBufferMode read _COLOR_ATTACHMENT2;
public static property COLOR_ATTACHMENT3: DrawBufferMode read _COLOR_ATTACHMENT3;
public static property COLOR_ATTACHMENT4: DrawBufferMode read _COLOR_ATTACHMENT4;
public static property COLOR_ATTACHMENT5: DrawBufferMode read _COLOR_ATTACHMENT5;
public static property COLOR_ATTACHMENT6: DrawBufferMode read _COLOR_ATTACHMENT6;
public static property COLOR_ATTACHMENT7: DrawBufferMode read _COLOR_ATTACHMENT7;
public static property COLOR_ATTACHMENT8: DrawBufferMode read _COLOR_ATTACHMENT8;
public static property COLOR_ATTACHMENT9: DrawBufferMode read _COLOR_ATTACHMENT9;
public static property COLOR_ATTACHMENT10: DrawBufferMode read _COLOR_ATTACHMENT10;
public static property COLOR_ATTACHMENT11: DrawBufferMode read _COLOR_ATTACHMENT11;
public static property COLOR_ATTACHMENT12: DrawBufferMode read _COLOR_ATTACHMENT12;
public static property COLOR_ATTACHMENT13: DrawBufferMode read _COLOR_ATTACHMENT13;
public static property COLOR_ATTACHMENT14: DrawBufferMode read _COLOR_ATTACHMENT14;
public static property COLOR_ATTACHMENT15: DrawBufferMode read _COLOR_ATTACHMENT15;
public static property COLOR_ATTACHMENT16: DrawBufferMode read _COLOR_ATTACHMENT16;
public static property COLOR_ATTACHMENT17: DrawBufferMode read _COLOR_ATTACHMENT17;
public static property COLOR_ATTACHMENT18: DrawBufferMode read _COLOR_ATTACHMENT18;
public static property COLOR_ATTACHMENT19: DrawBufferMode read _COLOR_ATTACHMENT19;
public static property COLOR_ATTACHMENT20: DrawBufferMode read _COLOR_ATTACHMENT20;
public static property COLOR_ATTACHMENT21: DrawBufferMode read _COLOR_ATTACHMENT21;
public static property COLOR_ATTACHMENT22: DrawBufferMode read _COLOR_ATTACHMENT22;
public static property COLOR_ATTACHMENT23: DrawBufferMode read _COLOR_ATTACHMENT23;
public static property COLOR_ATTACHMENT24: DrawBufferMode read _COLOR_ATTACHMENT24;
public static property COLOR_ATTACHMENT25: DrawBufferMode read _COLOR_ATTACHMENT25;
public static property COLOR_ATTACHMENT26: DrawBufferMode read _COLOR_ATTACHMENT26;
public static property COLOR_ATTACHMENT27: DrawBufferMode read _COLOR_ATTACHMENT27;
public static property COLOR_ATTACHMENT28: DrawBufferMode read _COLOR_ATTACHMENT28;
public static property COLOR_ATTACHMENT29: DrawBufferMode read _COLOR_ATTACHMENT29;
public static property COLOR_ATTACHMENT30: DrawBufferMode read _COLOR_ATTACHMENT30;
public static property COLOR_ATTACHMENT31: DrawBufferMode read _COLOR_ATTACHMENT31;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($0000) then Result := 'NONE_OES' else
if self.val = UInt32($0400) then Result := 'FRONT_LEFT' else
if self.val = UInt32($0401) then Result := 'FRONT_RIGHT' else
if self.val = UInt32($0402) then Result := 'BACK_LEFT' else
if self.val = UInt32($0403) then Result := 'BACK_RIGHT' else
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0406) then Result := 'LEFT' else
if self.val = UInt32($0407) then Result := 'RIGHT' else
if self.val = UInt32($0408) then Result := 'FRONT_AND_BACK' else
if self.val = UInt32($0409) then Result := 'AUX0' else
if self.val = UInt32($040A) then Result := 'AUX1' else
if self.val = UInt32($040B) then Result := 'AUX2' else
if self.val = UInt32($040C) then Result := 'AUX3' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15' else
if self.val = UInt32($8CF0) then Result := 'COLOR_ATTACHMENT16' else
if self.val = UInt32($8CF1) then Result := 'COLOR_ATTACHMENT17' else
if self.val = UInt32($8CF2) then Result := 'COLOR_ATTACHMENT18' else
if self.val = UInt32($8CF3) then Result := 'COLOR_ATTACHMENT19' else
if self.val = UInt32($8CF4) then Result := 'COLOR_ATTACHMENT20' else
if self.val = UInt32($8CF5) then Result := 'COLOR_ATTACHMENT21' else
if self.val = UInt32($8CF6) then Result := 'COLOR_ATTACHMENT22' else
if self.val = UInt32($8CF7) then Result := 'COLOR_ATTACHMENT23' else
if self.val = UInt32($8CF8) then Result := 'COLOR_ATTACHMENT24' else
if self.val = UInt32($8CF9) then Result := 'COLOR_ATTACHMENT25' else
if self.val = UInt32($8CFA) then Result := 'COLOR_ATTACHMENT26' else
if self.val = UInt32($8CFB) then Result := 'COLOR_ATTACHMENT27' else
if self.val = UInt32($8CFC) then Result := 'COLOR_ATTACHMENT28' else
if self.val = UInt32($8CFD) then Result := 'COLOR_ATTACHMENT29' else
if self.val = UInt32($8CFE) then Result := 'COLOR_ATTACHMENT30' else
if self.val = UInt32($8CFF) then Result := 'COLOR_ATTACHMENT31' else
Result := self.val.ToString;
end;
end;
DrawElementsType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_BYTE := new DrawElementsType($1401);
private static _UNSIGNED_SHORT := new DrawElementsType($1403);
private static _UNSIGNED_INT := new DrawElementsType($1405);
public static property UNSIGNED_BYTE: DrawElementsType read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: DrawElementsType read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: DrawElementsType read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
EnableCap = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINT_SMOOTH := new EnableCap($0B10);
private static _LINE_SMOOTH := new EnableCap($0B20);
private static _LINE_STIPPLE := new EnableCap($0B24);
private static _POLYGON_SMOOTH := new EnableCap($0B41);
private static _POLYGON_STIPPLE := new EnableCap($0B42);
private static _CULL_FACE := new EnableCap($0B44);
private static _LIGHTING := new EnableCap($0B50);
private static _COLOR_MATERIAL := new EnableCap($0B57);
private static _FOG := new EnableCap($0B60);
private static _DEPTH_TEST := new EnableCap($0B71);
private static _STENCIL_TEST := new EnableCap($0B90);
private static _NORMALIZE := new EnableCap($0BA1);
private static _ALPHA_TEST := new EnableCap($0BC0);
private static _DITHER := new EnableCap($0BD0);
private static _BLEND := new EnableCap($0BE2);
private static _INDEX_LOGIC_OP := new EnableCap($0BF1);
private static _COLOR_LOGIC_OP := new EnableCap($0BF2);
private static _SCISSOR_TEST := new EnableCap($0C11);
private static _TEXTURE_GEN_S := new EnableCap($0C60);
private static _TEXTURE_GEN_T := new EnableCap($0C61);
private static _TEXTURE_GEN_R := new EnableCap($0C62);
private static _TEXTURE_GEN_Q := new EnableCap($0C63);
private static _AUTO_NORMAL := new EnableCap($0D80);
private static _MAP1_COLOR_4 := new EnableCap($0D90);
private static _MAP1_INDEX := new EnableCap($0D91);
private static _MAP1_NORMAL := new EnableCap($0D92);
private static _MAP1_TEXTURE_COORD_1 := new EnableCap($0D93);
private static _MAP1_TEXTURE_COORD_2 := new EnableCap($0D94);
private static _MAP1_TEXTURE_COORD_3 := new EnableCap($0D95);
private static _MAP1_TEXTURE_COORD_4 := new EnableCap($0D96);
private static _MAP1_VERTEX_3 := new EnableCap($0D97);
private static _MAP1_VERTEX_4 := new EnableCap($0D98);
private static _MAP2_COLOR_4 := new EnableCap($0DB0);
private static _MAP2_INDEX := new EnableCap($0DB1);
private static _MAP2_NORMAL := new EnableCap($0DB2);
private static _MAP2_TEXTURE_COORD_1 := new EnableCap($0DB3);
private static _MAP2_TEXTURE_COORD_2 := new EnableCap($0DB4);
private static _MAP2_TEXTURE_COORD_3 := new EnableCap($0DB5);
private static _MAP2_TEXTURE_COORD_4 := new EnableCap($0DB6);
private static _MAP2_VERTEX_3 := new EnableCap($0DB7);
private static _MAP2_VERTEX_4 := new EnableCap($0DB8);
private static _TEXTURE_1D := new EnableCap($0DE0);
private static _TEXTURE_2D := new EnableCap($0DE1);
private static _POLYGON_OFFSET_POINT := new EnableCap($2A01);
private static _POLYGON_OFFSET_LINE := new EnableCap($2A02);
private static _CLIP_DISTANCE0 := new EnableCap($3000);
private static _CLIP_PLANE0 := new EnableCap($3000);
private static _CLIP_DISTANCE1 := new EnableCap($3001);
private static _CLIP_PLANE1 := new EnableCap($3001);
private static _CLIP_DISTANCE2 := new EnableCap($3002);
private static _CLIP_PLANE2 := new EnableCap($3002);
private static _CLIP_DISTANCE3 := new EnableCap($3003);
private static _CLIP_PLANE3 := new EnableCap($3003);
private static _CLIP_DISTANCE4 := new EnableCap($3004);
private static _CLIP_PLANE4 := new EnableCap($3004);
private static _CLIP_DISTANCE5 := new EnableCap($3005);
private static _CLIP_PLANE5 := new EnableCap($3005);
private static _CLIP_DISTANCE6 := new EnableCap($3006);
private static _CLIP_DISTANCE7 := new EnableCap($3007);
private static _LIGHT0 := new EnableCap($4000);
private static _LIGHT1 := new EnableCap($4001);
private static _LIGHT2 := new EnableCap($4002);
private static _LIGHT3 := new EnableCap($4003);
private static _LIGHT4 := new EnableCap($4004);
private static _LIGHT5 := new EnableCap($4005);
private static _LIGHT6 := new EnableCap($4006);
private static _LIGHT7 := new EnableCap($4007);
private static _CONVOLUTION_1D_EXT := new EnableCap($8010);
private static _CONVOLUTION_2D_EXT := new EnableCap($8011);
private static _SEPARABLE_2D_EXT := new EnableCap($8012);
private static _HISTOGRAM_EXT := new EnableCap($8024);
private static _MINMAX_EXT := new EnableCap($802E);
private static _POLYGON_OFFSET_FILL := new EnableCap($8037);
private static _RESCALE_NORMAL_EXT := new EnableCap($803A);
private static _TEXTURE_3D_EXT := new EnableCap($806F);
private static _VERTEX_ARRAY := new EnableCap($8074);
private static _NORMAL_ARRAY := new EnableCap($8075);
private static _COLOR_ARRAY := new EnableCap($8076);
private static _INDEX_ARRAY := new EnableCap($8077);
private static _TEXTURE_COORD_ARRAY := new EnableCap($8078);
private static _EDGE_FLAG_ARRAY := new EnableCap($8079);
private static _INTERLACE_SGIX := new EnableCap($8094);
private static _MULTISAMPLE := new EnableCap($809D);
private static _MULTISAMPLE_SGIS := new EnableCap($809D);
private static _SAMPLE_ALPHA_TO_COVERAGE := new EnableCap($809E);
private static _SAMPLE_ALPHA_TO_MASK_SGIS := new EnableCap($809E);
private static _SAMPLE_ALPHA_TO_ONE := new EnableCap($809F);
private static _SAMPLE_ALPHA_TO_ONE_SGIS := new EnableCap($809F);
private static _SAMPLE_COVERAGE := new EnableCap($80A0);
private static _SAMPLE_MASK_SGIS := new EnableCap($80A0);
private static _TEXTURE_COLOR_TABLE_SGI := new EnableCap($80BC);
private static _COLOR_TABLE_SGI := new EnableCap($80D0);
private static _POST_CONVOLUTION_COLOR_TABLE_SGI := new EnableCap($80D1);
private static _POST_COLOR_MATRIX_COLOR_TABLE_SGI := new EnableCap($80D2);
private static _TEXTURE_4D_SGIS := new EnableCap($8134);
private static _PIXEL_TEX_GEN_SGIX := new EnableCap($8139);
private static _SPRITE_SGIX := new EnableCap($8148);
private static _REFERENCE_PLANE_SGIX := new EnableCap($817D);
private static _IR_INSTRUMENT1_SGIX := new EnableCap($817F);
private static _CALLIGRAPHIC_FRAGMENT_SGIX := new EnableCap($8183);
private static _FRAMEZOOM_SGIX := new EnableCap($818B);
private static _FOG_OFFSET_SGIX := new EnableCap($8198);
private static _SHARED_TEXTURE_PALETTE_EXT := new EnableCap($81FB);
private static _DEBUG_OUTPUT_SYNCHRONOUS := new EnableCap($8242);
private static _ASYNC_HISTOGRAM_SGIX := new EnableCap($832C);
private static _PIXEL_TEXTURE_SGIS := new EnableCap($8353);
private static _ASYNC_TEX_IMAGE_SGIX := new EnableCap($835C);
private static _ASYNC_DRAW_PIXELS_SGIX := new EnableCap($835D);
private static _ASYNC_READ_PIXELS_SGIX := new EnableCap($835E);
private static _FRAGMENT_LIGHTING_SGIX := new EnableCap($8400);
private static _FRAGMENT_COLOR_MATERIAL_SGIX := new EnableCap($8401);
private static _FRAGMENT_LIGHT0_SGIX := new EnableCap($840C);
private static _FRAGMENT_LIGHT1_SGIX := new EnableCap($840D);
private static _FRAGMENT_LIGHT2_SGIX := new EnableCap($840E);
private static _FRAGMENT_LIGHT3_SGIX := new EnableCap($840F);
private static _FRAGMENT_LIGHT4_SGIX := new EnableCap($8410);
private static _FRAGMENT_LIGHT5_SGIX := new EnableCap($8411);
private static _FRAGMENT_LIGHT6_SGIX := new EnableCap($8412);
private static _FRAGMENT_LIGHT7_SGIX := new EnableCap($8413);
private static _PROGRAM_POINT_SIZE := new EnableCap($8642);
private static _DEPTH_CLAMP := new EnableCap($864F);
private static _TEXTURE_CUBE_MAP_SEAMLESS := new EnableCap($884F);
private static _SAMPLE_SHADING := new EnableCap($8C36);
private static _RASTERIZER_DISCARD := new EnableCap($8C89);
private static _PRIMITIVE_RESTART_FIXED_INDEX := new EnableCap($8D69);
private static _FRAMEBUFFER_SRGB := new EnableCap($8DB9);
private static _SAMPLE_MASK := new EnableCap($8E51);
private static _PRIMITIVE_RESTART := new EnableCap($8F9D);
private static _DEBUG_OUTPUT := new EnableCap($92E0);
public static property POINT_SMOOTH: EnableCap read _POINT_SMOOTH;
public static property LINE_SMOOTH: EnableCap read _LINE_SMOOTH;
public static property LINE_STIPPLE: EnableCap read _LINE_STIPPLE;
public static property POLYGON_SMOOTH: EnableCap read _POLYGON_SMOOTH;
public static property POLYGON_STIPPLE: EnableCap read _POLYGON_STIPPLE;
public static property CULL_FACE: EnableCap read _CULL_FACE;
public static property LIGHTING: EnableCap read _LIGHTING;
public static property COLOR_MATERIAL: EnableCap read _COLOR_MATERIAL;
public static property FOG: EnableCap read _FOG;
public static property DEPTH_TEST: EnableCap read _DEPTH_TEST;
public static property STENCIL_TEST: EnableCap read _STENCIL_TEST;
public static property NORMALIZE: EnableCap read _NORMALIZE;
public static property ALPHA_TEST: EnableCap read _ALPHA_TEST;
public static property DITHER: EnableCap read _DITHER;
public static property BLEND: EnableCap read _BLEND;
public static property INDEX_LOGIC_OP: EnableCap read _INDEX_LOGIC_OP;
public static property COLOR_LOGIC_OP: EnableCap read _COLOR_LOGIC_OP;
public static property SCISSOR_TEST: EnableCap read _SCISSOR_TEST;
public static property TEXTURE_GEN_S: EnableCap read _TEXTURE_GEN_S;
public static property TEXTURE_GEN_T: EnableCap read _TEXTURE_GEN_T;
public static property TEXTURE_GEN_R: EnableCap read _TEXTURE_GEN_R;
public static property TEXTURE_GEN_Q: EnableCap read _TEXTURE_GEN_Q;
public static property AUTO_NORMAL: EnableCap read _AUTO_NORMAL;
public static property MAP1_COLOR_4: EnableCap read _MAP1_COLOR_4;
public static property MAP1_INDEX: EnableCap read _MAP1_INDEX;
public static property MAP1_NORMAL: EnableCap read _MAP1_NORMAL;
public static property MAP1_TEXTURE_COORD_1: EnableCap read _MAP1_TEXTURE_COORD_1;
public static property MAP1_TEXTURE_COORD_2: EnableCap read _MAP1_TEXTURE_COORD_2;
public static property MAP1_TEXTURE_COORD_3: EnableCap read _MAP1_TEXTURE_COORD_3;
public static property MAP1_TEXTURE_COORD_4: EnableCap read _MAP1_TEXTURE_COORD_4;
public static property MAP1_VERTEX_3: EnableCap read _MAP1_VERTEX_3;
public static property MAP1_VERTEX_4: EnableCap read _MAP1_VERTEX_4;
public static property MAP2_COLOR_4: EnableCap read _MAP2_COLOR_4;
public static property MAP2_INDEX: EnableCap read _MAP2_INDEX;
public static property MAP2_NORMAL: EnableCap read _MAP2_NORMAL;
public static property MAP2_TEXTURE_COORD_1: EnableCap read _MAP2_TEXTURE_COORD_1;
public static property MAP2_TEXTURE_COORD_2: EnableCap read _MAP2_TEXTURE_COORD_2;
public static property MAP2_TEXTURE_COORD_3: EnableCap read _MAP2_TEXTURE_COORD_3;
public static property MAP2_TEXTURE_COORD_4: EnableCap read _MAP2_TEXTURE_COORD_4;
public static property MAP2_VERTEX_3: EnableCap read _MAP2_VERTEX_3;
public static property MAP2_VERTEX_4: EnableCap read _MAP2_VERTEX_4;
public static property TEXTURE_1D: EnableCap read _TEXTURE_1D;
public static property TEXTURE_2D: EnableCap read _TEXTURE_2D;
public static property POLYGON_OFFSET_POINT: EnableCap read _POLYGON_OFFSET_POINT;
public static property POLYGON_OFFSET_LINE: EnableCap read _POLYGON_OFFSET_LINE;
public static property CLIP_DISTANCE0: EnableCap read _CLIP_DISTANCE0;
public static property CLIP_PLANE0: EnableCap read _CLIP_PLANE0;
public static property CLIP_DISTANCE1: EnableCap read _CLIP_DISTANCE1;
public static property CLIP_PLANE1: EnableCap read _CLIP_PLANE1;
public static property CLIP_DISTANCE2: EnableCap read _CLIP_DISTANCE2;
public static property CLIP_PLANE2: EnableCap read _CLIP_PLANE2;
public static property CLIP_DISTANCE3: EnableCap read _CLIP_DISTANCE3;
public static property CLIP_PLANE3: EnableCap read _CLIP_PLANE3;
public static property CLIP_DISTANCE4: EnableCap read _CLIP_DISTANCE4;
public static property CLIP_PLANE4: EnableCap read _CLIP_PLANE4;
public static property CLIP_DISTANCE5: EnableCap read _CLIP_DISTANCE5;
public static property CLIP_PLANE5: EnableCap read _CLIP_PLANE5;
public static property CLIP_DISTANCE6: EnableCap read _CLIP_DISTANCE6;
public static property CLIP_DISTANCE7: EnableCap read _CLIP_DISTANCE7;
public static property LIGHT0: EnableCap read _LIGHT0;
public static property LIGHT1: EnableCap read _LIGHT1;
public static property LIGHT2: EnableCap read _LIGHT2;
public static property LIGHT3: EnableCap read _LIGHT3;
public static property LIGHT4: EnableCap read _LIGHT4;
public static property LIGHT5: EnableCap read _LIGHT5;
public static property LIGHT6: EnableCap read _LIGHT6;
public static property LIGHT7: EnableCap read _LIGHT7;
public static property CONVOLUTION_1D_EXT: EnableCap read _CONVOLUTION_1D_EXT;
public static property CONVOLUTION_2D_EXT: EnableCap read _CONVOLUTION_2D_EXT;
public static property SEPARABLE_2D_EXT: EnableCap read _SEPARABLE_2D_EXT;
public static property HISTOGRAM_EXT: EnableCap read _HISTOGRAM_EXT;
public static property MINMAX_EXT: EnableCap read _MINMAX_EXT;
public static property POLYGON_OFFSET_FILL: EnableCap read _POLYGON_OFFSET_FILL;
public static property RESCALE_NORMAL_EXT: EnableCap read _RESCALE_NORMAL_EXT;
public static property TEXTURE_3D_EXT: EnableCap read _TEXTURE_3D_EXT;
public static property VERTEX_ARRAY: EnableCap read _VERTEX_ARRAY;
public static property NORMAL_ARRAY: EnableCap read _NORMAL_ARRAY;
public static property COLOR_ARRAY: EnableCap read _COLOR_ARRAY;
public static property INDEX_ARRAY: EnableCap read _INDEX_ARRAY;
public static property TEXTURE_COORD_ARRAY: EnableCap read _TEXTURE_COORD_ARRAY;
public static property EDGE_FLAG_ARRAY: EnableCap read _EDGE_FLAG_ARRAY;
public static property INTERLACE_SGIX: EnableCap read _INTERLACE_SGIX;
public static property MULTISAMPLE: EnableCap read _MULTISAMPLE;
public static property MULTISAMPLE_SGIS: EnableCap read _MULTISAMPLE_SGIS;
public static property SAMPLE_ALPHA_TO_COVERAGE: EnableCap read _SAMPLE_ALPHA_TO_COVERAGE;
public static property SAMPLE_ALPHA_TO_MASK_SGIS: EnableCap read _SAMPLE_ALPHA_TO_MASK_SGIS;
public static property SAMPLE_ALPHA_TO_ONE: EnableCap read _SAMPLE_ALPHA_TO_ONE;
public static property SAMPLE_ALPHA_TO_ONE_SGIS: EnableCap read _SAMPLE_ALPHA_TO_ONE_SGIS;
public static property SAMPLE_COVERAGE: EnableCap read _SAMPLE_COVERAGE;
public static property SAMPLE_MASK_SGIS: EnableCap read _SAMPLE_MASK_SGIS;
public static property TEXTURE_COLOR_TABLE_SGI: EnableCap read _TEXTURE_COLOR_TABLE_SGI;
public static property COLOR_TABLE_SGI: EnableCap read _COLOR_TABLE_SGI;
public static property POST_CONVOLUTION_COLOR_TABLE_SGI: EnableCap read _POST_CONVOLUTION_COLOR_TABLE_SGI;
public static property POST_COLOR_MATRIX_COLOR_TABLE_SGI: EnableCap read _POST_COLOR_MATRIX_COLOR_TABLE_SGI;
public static property TEXTURE_4D_SGIS: EnableCap read _TEXTURE_4D_SGIS;
public static property PIXEL_TEX_GEN_SGIX: EnableCap read _PIXEL_TEX_GEN_SGIX;
public static property SPRITE_SGIX: EnableCap read _SPRITE_SGIX;
public static property REFERENCE_PLANE_SGIX: EnableCap read _REFERENCE_PLANE_SGIX;
public static property IR_INSTRUMENT1_SGIX: EnableCap read _IR_INSTRUMENT1_SGIX;
public static property CALLIGRAPHIC_FRAGMENT_SGIX: EnableCap read _CALLIGRAPHIC_FRAGMENT_SGIX;
public static property FRAMEZOOM_SGIX: EnableCap read _FRAMEZOOM_SGIX;
public static property FOG_OFFSET_SGIX: EnableCap read _FOG_OFFSET_SGIX;
public static property SHARED_TEXTURE_PALETTE_EXT: EnableCap read _SHARED_TEXTURE_PALETTE_EXT;
public static property DEBUG_OUTPUT_SYNCHRONOUS: EnableCap read _DEBUG_OUTPUT_SYNCHRONOUS;
public static property ASYNC_HISTOGRAM_SGIX: EnableCap read _ASYNC_HISTOGRAM_SGIX;
public static property PIXEL_TEXTURE_SGIS: EnableCap read _PIXEL_TEXTURE_SGIS;
public static property ASYNC_TEX_IMAGE_SGIX: EnableCap read _ASYNC_TEX_IMAGE_SGIX;
public static property ASYNC_DRAW_PIXELS_SGIX: EnableCap read _ASYNC_DRAW_PIXELS_SGIX;
public static property ASYNC_READ_PIXELS_SGIX: EnableCap read _ASYNC_READ_PIXELS_SGIX;
public static property FRAGMENT_LIGHTING_SGIX: EnableCap read _FRAGMENT_LIGHTING_SGIX;
public static property FRAGMENT_COLOR_MATERIAL_SGIX: EnableCap read _FRAGMENT_COLOR_MATERIAL_SGIX;
public static property FRAGMENT_LIGHT0_SGIX: EnableCap read _FRAGMENT_LIGHT0_SGIX;
public static property FRAGMENT_LIGHT1_SGIX: EnableCap read _FRAGMENT_LIGHT1_SGIX;
public static property FRAGMENT_LIGHT2_SGIX: EnableCap read _FRAGMENT_LIGHT2_SGIX;
public static property FRAGMENT_LIGHT3_SGIX: EnableCap read _FRAGMENT_LIGHT3_SGIX;
public static property FRAGMENT_LIGHT4_SGIX: EnableCap read _FRAGMENT_LIGHT4_SGIX;
public static property FRAGMENT_LIGHT5_SGIX: EnableCap read _FRAGMENT_LIGHT5_SGIX;
public static property FRAGMENT_LIGHT6_SGIX: EnableCap read _FRAGMENT_LIGHT6_SGIX;
public static property FRAGMENT_LIGHT7_SGIX: EnableCap read _FRAGMENT_LIGHT7_SGIX;
public static property PROGRAM_POINT_SIZE: EnableCap read _PROGRAM_POINT_SIZE;
public static property DEPTH_CLAMP: EnableCap read _DEPTH_CLAMP;
public static property TEXTURE_CUBE_MAP_SEAMLESS: EnableCap read _TEXTURE_CUBE_MAP_SEAMLESS;
public static property SAMPLE_SHADING: EnableCap read _SAMPLE_SHADING;
public static property RASTERIZER_DISCARD: EnableCap read _RASTERIZER_DISCARD;
public static property PRIMITIVE_RESTART_FIXED_INDEX: EnableCap read _PRIMITIVE_RESTART_FIXED_INDEX;
public static property FRAMEBUFFER_SRGB: EnableCap read _FRAMEBUFFER_SRGB;
public static property SAMPLE_MASK: EnableCap read _SAMPLE_MASK;
public static property PRIMITIVE_RESTART: EnableCap read _PRIMITIVE_RESTART;
public static property DEBUG_OUTPUT: EnableCap read _DEBUG_OUTPUT;
public function ToString: string; override;
begin
if self.val = UInt32($0B10) then Result := 'POINT_SMOOTH' else
if self.val = UInt32($0B20) then Result := 'LINE_SMOOTH' else
if self.val = UInt32($0B24) then Result := 'LINE_STIPPLE' else
if self.val = UInt32($0B41) then Result := 'POLYGON_SMOOTH' else
if self.val = UInt32($0B42) then Result := 'POLYGON_STIPPLE' else
if self.val = UInt32($0B44) then Result := 'CULL_FACE' else
if self.val = UInt32($0B50) then Result := 'LIGHTING' else
if self.val = UInt32($0B57) then Result := 'COLOR_MATERIAL' else
if self.val = UInt32($0B60) then Result := 'FOG' else
if self.val = UInt32($0B71) then Result := 'DEPTH_TEST' else
if self.val = UInt32($0B90) then Result := 'STENCIL_TEST' else
if self.val = UInt32($0BA1) then Result := 'NORMALIZE' else
if self.val = UInt32($0BC0) then Result := 'ALPHA_TEST' else
if self.val = UInt32($0BD0) then Result := 'DITHER' else
if self.val = UInt32($0BE2) then Result := 'BLEND' else
if self.val = UInt32($0BF1) then Result := 'INDEX_LOGIC_OP' else
if self.val = UInt32($0BF2) then Result := 'COLOR_LOGIC_OP' else
if self.val = UInt32($0C11) then Result := 'SCISSOR_TEST' else
if self.val = UInt32($0C60) then Result := 'TEXTURE_GEN_S' else
if self.val = UInt32($0C61) then Result := 'TEXTURE_GEN_T' else
if self.val = UInt32($0C62) then Result := 'TEXTURE_GEN_R' else
if self.val = UInt32($0C63) then Result := 'TEXTURE_GEN_Q' else
if self.val = UInt32($0D80) then Result := 'AUTO_NORMAL' else
if self.val = UInt32($0D90) then Result := 'MAP1_COLOR_4' else
if self.val = UInt32($0D91) then Result := 'MAP1_INDEX' else
if self.val = UInt32($0D92) then Result := 'MAP1_NORMAL' else
if self.val = UInt32($0D93) then Result := 'MAP1_TEXTURE_COORD_1' else
if self.val = UInt32($0D94) then Result := 'MAP1_TEXTURE_COORD_2' else
if self.val = UInt32($0D95) then Result := 'MAP1_TEXTURE_COORD_3' else
if self.val = UInt32($0D96) then Result := 'MAP1_TEXTURE_COORD_4' else
if self.val = UInt32($0D97) then Result := 'MAP1_VERTEX_3' else
if self.val = UInt32($0D98) then Result := 'MAP1_VERTEX_4' else
if self.val = UInt32($0DB0) then Result := 'MAP2_COLOR_4' else
if self.val = UInt32($0DB1) then Result := 'MAP2_INDEX' else
if self.val = UInt32($0DB2) then Result := 'MAP2_NORMAL' else
if self.val = UInt32($0DB3) then Result := 'MAP2_TEXTURE_COORD_1' else
if self.val = UInt32($0DB4) then Result := 'MAP2_TEXTURE_COORD_2' else
if self.val = UInt32($0DB5) then Result := 'MAP2_TEXTURE_COORD_3' else
if self.val = UInt32($0DB6) then Result := 'MAP2_TEXTURE_COORD_4' else
if self.val = UInt32($0DB7) then Result := 'MAP2_VERTEX_3' else
if self.val = UInt32($0DB8) then Result := 'MAP2_VERTEX_4' else
if self.val = UInt32($0DE0) then Result := 'TEXTURE_1D' else
if self.val = UInt32($0DE1) then Result := 'TEXTURE_2D' else
if self.val = UInt32($2A01) then Result := 'POLYGON_OFFSET_POINT' else
if self.val = UInt32($2A02) then Result := 'POLYGON_OFFSET_LINE' else
if self.val = UInt32($3000) then Result := 'CLIP_DISTANCE0' else
if self.val = UInt32($3000) then Result := 'CLIP_PLANE0' else
if self.val = UInt32($3001) then Result := 'CLIP_DISTANCE1' else
if self.val = UInt32($3001) then Result := 'CLIP_PLANE1' else
if self.val = UInt32($3002) then Result := 'CLIP_DISTANCE2' else
if self.val = UInt32($3002) then Result := 'CLIP_PLANE2' else
if self.val = UInt32($3003) then Result := 'CLIP_DISTANCE3' else
if self.val = UInt32($3003) then Result := 'CLIP_PLANE3' else
if self.val = UInt32($3004) then Result := 'CLIP_DISTANCE4' else
if self.val = UInt32($3004) then Result := 'CLIP_PLANE4' else
if self.val = UInt32($3005) then Result := 'CLIP_DISTANCE5' else
if self.val = UInt32($3005) then Result := 'CLIP_PLANE5' else
if self.val = UInt32($3006) then Result := 'CLIP_DISTANCE6' else
if self.val = UInt32($3007) then Result := 'CLIP_DISTANCE7' else
if self.val = UInt32($4000) then Result := 'LIGHT0' else
if self.val = UInt32($4001) then Result := 'LIGHT1' else
if self.val = UInt32($4002) then Result := 'LIGHT2' else
if self.val = UInt32($4003) then Result := 'LIGHT3' else
if self.val = UInt32($4004) then Result := 'LIGHT4' else
if self.val = UInt32($4005) then Result := 'LIGHT5' else
if self.val = UInt32($4006) then Result := 'LIGHT6' else
if self.val = UInt32($4007) then Result := 'LIGHT7' else
if self.val = UInt32($8010) then Result := 'CONVOLUTION_1D_EXT' else
if self.val = UInt32($8011) then Result := 'CONVOLUTION_2D_EXT' else
if self.val = UInt32($8012) then Result := 'SEPARABLE_2D_EXT' else
if self.val = UInt32($8024) then Result := 'HISTOGRAM_EXT' else
if self.val = UInt32($802E) then Result := 'MINMAX_EXT' else
if self.val = UInt32($8037) then Result := 'POLYGON_OFFSET_FILL' else
if self.val = UInt32($803A) then Result := 'RESCALE_NORMAL_EXT' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D_EXT' else
if self.val = UInt32($8074) then Result := 'VERTEX_ARRAY' else
if self.val = UInt32($8075) then Result := 'NORMAL_ARRAY' else
if self.val = UInt32($8076) then Result := 'COLOR_ARRAY' else
if self.val = UInt32($8077) then Result := 'INDEX_ARRAY' else
if self.val = UInt32($8078) then Result := 'TEXTURE_COORD_ARRAY' else
if self.val = UInt32($8079) then Result := 'EDGE_FLAG_ARRAY' else
if self.val = UInt32($8094) then Result := 'INTERLACE_SGIX' else
if self.val = UInt32($809D) then Result := 'MULTISAMPLE' else
if self.val = UInt32($809D) then Result := 'MULTISAMPLE_SGIS' else
if self.val = UInt32($809E) then Result := 'SAMPLE_ALPHA_TO_COVERAGE' else
if self.val = UInt32($809E) then Result := 'SAMPLE_ALPHA_TO_MASK_SGIS' else
if self.val = UInt32($809F) then Result := 'SAMPLE_ALPHA_TO_ONE' else
if self.val = UInt32($809F) then Result := 'SAMPLE_ALPHA_TO_ONE_SGIS' else
if self.val = UInt32($80A0) then Result := 'SAMPLE_COVERAGE' else
if self.val = UInt32($80A0) then Result := 'SAMPLE_MASK_SGIS' else
if self.val = UInt32($80BC) then Result := 'TEXTURE_COLOR_TABLE_SGI' else
if self.val = UInt32($80D0) then Result := 'COLOR_TABLE_SGI' else
if self.val = UInt32($80D1) then Result := 'POST_CONVOLUTION_COLOR_TABLE_SGI' else
if self.val = UInt32($80D2) then Result := 'POST_COLOR_MATRIX_COLOR_TABLE_SGI' else
if self.val = UInt32($8134) then Result := 'TEXTURE_4D_SGIS' else
if self.val = UInt32($8139) then Result := 'PIXEL_TEX_GEN_SGIX' else
if self.val = UInt32($8148) then Result := 'SPRITE_SGIX' else
if self.val = UInt32($817D) then Result := 'REFERENCE_PLANE_SGIX' else
if self.val = UInt32($817F) then Result := 'IR_INSTRUMENT1_SGIX' else
if self.val = UInt32($8183) then Result := 'CALLIGRAPHIC_FRAGMENT_SGIX' else
if self.val = UInt32($818B) then Result := 'FRAMEZOOM_SGIX' else
if self.val = UInt32($8198) then Result := 'FOG_OFFSET_SGIX' else
if self.val = UInt32($81FB) then Result := 'SHARED_TEXTURE_PALETTE_EXT' else
if self.val = UInt32($8242) then Result := 'DEBUG_OUTPUT_SYNCHRONOUS' else
if self.val = UInt32($832C) then Result := 'ASYNC_HISTOGRAM_SGIX' else
if self.val = UInt32($8353) then Result := 'PIXEL_TEXTURE_SGIS' else
if self.val = UInt32($835C) then Result := 'ASYNC_TEX_IMAGE_SGIX' else
if self.val = UInt32($835D) then Result := 'ASYNC_DRAW_PIXELS_SGIX' else
if self.val = UInt32($835E) then Result := 'ASYNC_READ_PIXELS_SGIX' else
if self.val = UInt32($8400) then Result := 'FRAGMENT_LIGHTING_SGIX' else
if self.val = UInt32($8401) then Result := 'FRAGMENT_COLOR_MATERIAL_SGIX' else
if self.val = UInt32($840C) then Result := 'FRAGMENT_LIGHT0_SGIX' else
if self.val = UInt32($840D) then Result := 'FRAGMENT_LIGHT1_SGIX' else
if self.val = UInt32($840E) then Result := 'FRAGMENT_LIGHT2_SGIX' else
if self.val = UInt32($840F) then Result := 'FRAGMENT_LIGHT3_SGIX' else
if self.val = UInt32($8410) then Result := 'FRAGMENT_LIGHT4_SGIX' else
if self.val = UInt32($8411) then Result := 'FRAGMENT_LIGHT5_SGIX' else
if self.val = UInt32($8412) then Result := 'FRAGMENT_LIGHT6_SGIX' else
if self.val = UInt32($8413) then Result := 'FRAGMENT_LIGHT7_SGIX' else
if self.val = UInt32($8642) then Result := 'PROGRAM_POINT_SIZE' else
if self.val = UInt32($864F) then Result := 'DEPTH_CLAMP' else
if self.val = UInt32($884F) then Result := 'TEXTURE_CUBE_MAP_SEAMLESS' else
if self.val = UInt32($8C36) then Result := 'SAMPLE_SHADING' else
if self.val = UInt32($8C89) then Result := 'RASTERIZER_DISCARD' else
if self.val = UInt32($8D69) then Result := 'PRIMITIVE_RESTART_FIXED_INDEX' else
if self.val = UInt32($8DB9) then Result := 'FRAMEBUFFER_SRGB' else
if self.val = UInt32($8E51) then Result := 'SAMPLE_MASK' else
if self.val = UInt32($8F9D) then Result := 'PRIMITIVE_RESTART' else
if self.val = UInt32($92E0) then Result := 'DEBUG_OUTPUT' else
Result := self.val.ToString;
end;
end;
ErrorCode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NO_ERROR := new ErrorCode($0000);
private static _INVALID_ENUM := new ErrorCode($0500);
private static _INVALID_VALUE := new ErrorCode($0501);
private static _INVALID_OPERATION := new ErrorCode($0502);
private static _STACK_OVERFLOW := new ErrorCode($0503);
private static _STACK_UNDERFLOW := new ErrorCode($0504);
private static _OUT_OF_MEMORY := new ErrorCode($0505);
private static _INVALID_FRAMEBUFFER_OPERATION := new ErrorCode($0506);
private static _INVALID_FRAMEBUFFER_OPERATION_EXT := new ErrorCode($0506);
private static _INVALID_FRAMEBUFFER_OPERATION_OES := new ErrorCode($0506);
private static _TABLE_TOO_LARGE := new ErrorCode($8031);
private static _TABLE_TOO_LARGE_EXT := new ErrorCode($8031);
private static _TEXTURE_TOO_LARGE_EXT := new ErrorCode($8065);
public static property NO_ERROR: ErrorCode read _NO_ERROR;
public static property INVALID_ENUM: ErrorCode read _INVALID_ENUM;
public static property INVALID_VALUE: ErrorCode read _INVALID_VALUE;
public static property INVALID_OPERATION: ErrorCode read _INVALID_OPERATION;
public static property STACK_OVERFLOW: ErrorCode read _STACK_OVERFLOW;
public static property STACK_UNDERFLOW: ErrorCode read _STACK_UNDERFLOW;
public static property OUT_OF_MEMORY: ErrorCode read _OUT_OF_MEMORY;
public static property INVALID_FRAMEBUFFER_OPERATION: ErrorCode read _INVALID_FRAMEBUFFER_OPERATION;
public static property INVALID_FRAMEBUFFER_OPERATION_EXT: ErrorCode read _INVALID_FRAMEBUFFER_OPERATION_EXT;
public static property INVALID_FRAMEBUFFER_OPERATION_OES: ErrorCode read _INVALID_FRAMEBUFFER_OPERATION_OES;
public static property TABLE_TOO_LARGE: ErrorCode read _TABLE_TOO_LARGE;
public static property TABLE_TOO_LARGE_EXT: ErrorCode read _TABLE_TOO_LARGE_EXT;
public static property TEXTURE_TOO_LARGE_EXT: ErrorCode read _TEXTURE_TOO_LARGE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NO_ERROR' else
if self.val = UInt32($0500) then Result := 'INVALID_ENUM' else
if self.val = UInt32($0501) then Result := 'INVALID_VALUE' else
if self.val = UInt32($0502) then Result := 'INVALID_OPERATION' else
if self.val = UInt32($0503) then Result := 'STACK_OVERFLOW' else
if self.val = UInt32($0504) then Result := 'STACK_UNDERFLOW' else
if self.val = UInt32($0505) then Result := 'OUT_OF_MEMORY' else
if self.val = UInt32($0506) then Result := 'INVALID_FRAMEBUFFER_OPERATION' else
if self.val = UInt32($0506) then Result := 'INVALID_FRAMEBUFFER_OPERATION_EXT' else
if self.val = UInt32($0506) then Result := 'INVALID_FRAMEBUFFER_OPERATION_OES' else
if self.val = UInt32($8031) then Result := 'TABLE_TOO_LARGE' else
if self.val = UInt32($8031) then Result := 'TABLE_TOO_LARGE_EXT' else
if self.val = UInt32($8065) then Result := 'TEXTURE_TOO_LARGE_EXT' else
Result := self.val.ToString;
end;
end;
ExternalHandleType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _HANDLE_TYPE_OPAQUE_FD_EXT := new ExternalHandleType($9586);
private static _HANDLE_TYPE_OPAQUE_WIN32_EXT := new ExternalHandleType($9587);
private static _HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT := new ExternalHandleType($9588);
private static _HANDLE_TYPE_D3D12_TILEPOOL_EXT := new ExternalHandleType($9589);
private static _HANDLE_TYPE_D3D12_RESOURCE_EXT := new ExternalHandleType($958A);
private static _HANDLE_TYPE_D3D11_IMAGE_EXT := new ExternalHandleType($958B);
private static _HANDLE_TYPE_D3D11_IMAGE_KMT_EXT := new ExternalHandleType($958C);
private static _HANDLE_TYPE_D3D12_FENCE_EXT := new ExternalHandleType($9594);
public static property HANDLE_TYPE_OPAQUE_FD_EXT: ExternalHandleType read _HANDLE_TYPE_OPAQUE_FD_EXT;
public static property HANDLE_TYPE_OPAQUE_WIN32_EXT: ExternalHandleType read _HANDLE_TYPE_OPAQUE_WIN32_EXT;
public static property HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT: ExternalHandleType read _HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT;
public static property HANDLE_TYPE_D3D12_TILEPOOL_EXT: ExternalHandleType read _HANDLE_TYPE_D3D12_TILEPOOL_EXT;
public static property HANDLE_TYPE_D3D12_RESOURCE_EXT: ExternalHandleType read _HANDLE_TYPE_D3D12_RESOURCE_EXT;
public static property HANDLE_TYPE_D3D11_IMAGE_EXT: ExternalHandleType read _HANDLE_TYPE_D3D11_IMAGE_EXT;
public static property HANDLE_TYPE_D3D11_IMAGE_KMT_EXT: ExternalHandleType read _HANDLE_TYPE_D3D11_IMAGE_KMT_EXT;
public static property HANDLE_TYPE_D3D12_FENCE_EXT: ExternalHandleType read _HANDLE_TYPE_D3D12_FENCE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($9586) then Result := 'HANDLE_TYPE_OPAQUE_FD_EXT' else
if self.val = UInt32($9587) then Result := 'HANDLE_TYPE_OPAQUE_WIN32_EXT' else
if self.val = UInt32($9588) then Result := 'HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT' else
if self.val = UInt32($9589) then Result := 'HANDLE_TYPE_D3D12_TILEPOOL_EXT' else
if self.val = UInt32($958A) then Result := 'HANDLE_TYPE_D3D12_RESOURCE_EXT' else
if self.val = UInt32($958B) then Result := 'HANDLE_TYPE_D3D11_IMAGE_EXT' else
if self.val = UInt32($958C) then Result := 'HANDLE_TYPE_D3D11_IMAGE_KMT_EXT' else
if self.val = UInt32($9594) then Result := 'HANDLE_TYPE_D3D12_FENCE_EXT' else
Result := self.val.ToString;
end;
end;
FeedbackType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _GL_2D := new FeedbackType($0600);
private static _GL_3D := new FeedbackType($0601);
private static _GL_3D_COLOR := new FeedbackType($0602);
private static _GL_3D_COLOR_TEXTURE := new FeedbackType($0603);
private static _GL_4D_COLOR_TEXTURE := new FeedbackType($0604);
public static property GL_2D: FeedbackType read _GL_2D;
public static property GL_3D: FeedbackType read _GL_3D;
public static property GL_3D_COLOR: FeedbackType read _GL_3D_COLOR;
public static property GL_3D_COLOR_TEXTURE: FeedbackType read _GL_3D_COLOR_TEXTURE;
public static property GL_4D_COLOR_TEXTURE: FeedbackType read _GL_4D_COLOR_TEXTURE;
public function ToString: string; override;
begin
if self.val = UInt32($0600) then Result := 'GL_2D' else
if self.val = UInt32($0601) then Result := 'GL_3D' else
if self.val = UInt32($0602) then Result := 'GL_3D_COLOR' else
if self.val = UInt32($0603) then Result := 'GL_3D_COLOR_TEXTURE' else
if self.val = UInt32($0604) then Result := 'GL_4D_COLOR_TEXTURE' else
Result := self.val.ToString;
end;
end;
FogCoordinatePointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLOAT := new FogCoordinatePointerType($1406);
private static _DOUBLE := new FogCoordinatePointerType($140A);
public static property FLOAT: FogCoordinatePointerType read _FLOAT;
public static property DOUBLE: FogCoordinatePointerType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
FogParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FOG_INDEX := new FogParameter($0B61);
private static _FOG_DENSITY := new FogParameter($0B62);
private static _FOG_START := new FogParameter($0B63);
private static _FOG_END := new FogParameter($0B64);
private static _FOG_MODE := new FogParameter($0B65);
private static _FOG_COLOR := new FogParameter($0B66);
private static _FOG_OFFSET_VALUE_SGIX := new FogParameter($8199);
public static property FOG_INDEX: FogParameter read _FOG_INDEX;
public static property FOG_DENSITY: FogParameter read _FOG_DENSITY;
public static property FOG_START: FogParameter read _FOG_START;
public static property FOG_END: FogParameter read _FOG_END;
public static property FOG_MODE: FogParameter read _FOG_MODE;
public static property FOG_COLOR: FogParameter read _FOG_COLOR;
public static property FOG_OFFSET_VALUE_SGIX: FogParameter read _FOG_OFFSET_VALUE_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($0B61) then Result := 'FOG_INDEX' else
if self.val = UInt32($0B62) then Result := 'FOG_DENSITY' else
if self.val = UInt32($0B63) then Result := 'FOG_START' else
if self.val = UInt32($0B64) then Result := 'FOG_END' else
if self.val = UInt32($0B65) then Result := 'FOG_MODE' else
if self.val = UInt32($0B66) then Result := 'FOG_COLOR' else
if self.val = UInt32($8199) then Result := 'FOG_OFFSET_VALUE_SGIX' else
Result := self.val.ToString;
end;
end;
FogPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FOG_INDEX := new FogPName($0B61);
private static _FOG_DENSITY := new FogPName($0B62);
private static _FOG_START := new FogPName($0B63);
private static _FOG_END := new FogPName($0B64);
private static _FOG_MODE := new FogPName($0B65);
private static _FOG_COORD_SRC := new FogPName($8450);
public static property FOG_INDEX: FogPName read _FOG_INDEX;
public static property FOG_DENSITY: FogPName read _FOG_DENSITY;
public static property FOG_START: FogPName read _FOG_START;
public static property FOG_END: FogPName read _FOG_END;
public static property FOG_MODE: FogPName read _FOG_MODE;
public static property FOG_COORD_SRC: FogPName read _FOG_COORD_SRC;
public function ToString: string; override;
begin
if self.val = UInt32($0B61) then Result := 'FOG_INDEX' else
if self.val = UInt32($0B62) then Result := 'FOG_DENSITY' else
if self.val = UInt32($0B63) then Result := 'FOG_START' else
if self.val = UInt32($0B64) then Result := 'FOG_END' else
if self.val = UInt32($0B65) then Result := 'FOG_MODE' else
if self.val = UInt32($8450) then Result := 'FOG_COORD_SRC' else
Result := self.val.ToString;
end;
end;
FramebufferAttachment = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR_ATTACHMENT0 := new FramebufferAttachment($8CE0);
private static _COLOR_ATTACHMENT1 := new FramebufferAttachment($8CE1);
private static _COLOR_ATTACHMENT2 := new FramebufferAttachment($8CE2);
private static _COLOR_ATTACHMENT3 := new FramebufferAttachment($8CE3);
private static _COLOR_ATTACHMENT4 := new FramebufferAttachment($8CE4);
private static _COLOR_ATTACHMENT5 := new FramebufferAttachment($8CE5);
private static _COLOR_ATTACHMENT6 := new FramebufferAttachment($8CE6);
private static _COLOR_ATTACHMENT7 := new FramebufferAttachment($8CE7);
private static _COLOR_ATTACHMENT8 := new FramebufferAttachment($8CE8);
private static _COLOR_ATTACHMENT9 := new FramebufferAttachment($8CE9);
private static _COLOR_ATTACHMENT10 := new FramebufferAttachment($8CEA);
private static _COLOR_ATTACHMENT11 := new FramebufferAttachment($8CEB);
private static _COLOR_ATTACHMENT12 := new FramebufferAttachment($8CEC);
private static _COLOR_ATTACHMENT13 := new FramebufferAttachment($8CED);
private static _COLOR_ATTACHMENT14 := new FramebufferAttachment($8CEE);
private static _COLOR_ATTACHMENT15 := new FramebufferAttachment($8CEF);
private static _COLOR_ATTACHMENT16 := new FramebufferAttachment($8CF0);
private static _COLOR_ATTACHMENT17 := new FramebufferAttachment($8CF1);
private static _COLOR_ATTACHMENT18 := new FramebufferAttachment($8CF2);
private static _COLOR_ATTACHMENT19 := new FramebufferAttachment($8CF3);
private static _COLOR_ATTACHMENT20 := new FramebufferAttachment($8CF4);
private static _COLOR_ATTACHMENT21 := new FramebufferAttachment($8CF5);
private static _COLOR_ATTACHMENT22 := new FramebufferAttachment($8CF6);
private static _COLOR_ATTACHMENT23 := new FramebufferAttachment($8CF7);
private static _COLOR_ATTACHMENT24 := new FramebufferAttachment($8CF8);
private static _COLOR_ATTACHMENT25 := new FramebufferAttachment($8CF9);
private static _COLOR_ATTACHMENT26 := new FramebufferAttachment($8CFA);
private static _COLOR_ATTACHMENT27 := new FramebufferAttachment($8CFB);
private static _COLOR_ATTACHMENT28 := new FramebufferAttachment($8CFC);
private static _COLOR_ATTACHMENT29 := new FramebufferAttachment($8CFD);
private static _COLOR_ATTACHMENT30 := new FramebufferAttachment($8CFE);
private static _COLOR_ATTACHMENT31 := new FramebufferAttachment($8CFF);
private static _STENCIL_ATTACHMENT := new FramebufferAttachment($8D20);
public static property COLOR_ATTACHMENT0: FramebufferAttachment read _COLOR_ATTACHMENT0;
public static property COLOR_ATTACHMENT1: FramebufferAttachment read _COLOR_ATTACHMENT1;
public static property COLOR_ATTACHMENT2: FramebufferAttachment read _COLOR_ATTACHMENT2;
public static property COLOR_ATTACHMENT3: FramebufferAttachment read _COLOR_ATTACHMENT3;
public static property COLOR_ATTACHMENT4: FramebufferAttachment read _COLOR_ATTACHMENT4;
public static property COLOR_ATTACHMENT5: FramebufferAttachment read _COLOR_ATTACHMENT5;
public static property COLOR_ATTACHMENT6: FramebufferAttachment read _COLOR_ATTACHMENT6;
public static property COLOR_ATTACHMENT7: FramebufferAttachment read _COLOR_ATTACHMENT7;
public static property COLOR_ATTACHMENT8: FramebufferAttachment read _COLOR_ATTACHMENT8;
public static property COLOR_ATTACHMENT9: FramebufferAttachment read _COLOR_ATTACHMENT9;
public static property COLOR_ATTACHMENT10: FramebufferAttachment read _COLOR_ATTACHMENT10;
public static property COLOR_ATTACHMENT11: FramebufferAttachment read _COLOR_ATTACHMENT11;
public static property COLOR_ATTACHMENT12: FramebufferAttachment read _COLOR_ATTACHMENT12;
public static property COLOR_ATTACHMENT13: FramebufferAttachment read _COLOR_ATTACHMENT13;
public static property COLOR_ATTACHMENT14: FramebufferAttachment read _COLOR_ATTACHMENT14;
public static property COLOR_ATTACHMENT15: FramebufferAttachment read _COLOR_ATTACHMENT15;
public static property COLOR_ATTACHMENT16: FramebufferAttachment read _COLOR_ATTACHMENT16;
public static property COLOR_ATTACHMENT17: FramebufferAttachment read _COLOR_ATTACHMENT17;
public static property COLOR_ATTACHMENT18: FramebufferAttachment read _COLOR_ATTACHMENT18;
public static property COLOR_ATTACHMENT19: FramebufferAttachment read _COLOR_ATTACHMENT19;
public static property COLOR_ATTACHMENT20: FramebufferAttachment read _COLOR_ATTACHMENT20;
public static property COLOR_ATTACHMENT21: FramebufferAttachment read _COLOR_ATTACHMENT21;
public static property COLOR_ATTACHMENT22: FramebufferAttachment read _COLOR_ATTACHMENT22;
public static property COLOR_ATTACHMENT23: FramebufferAttachment read _COLOR_ATTACHMENT23;
public static property COLOR_ATTACHMENT24: FramebufferAttachment read _COLOR_ATTACHMENT24;
public static property COLOR_ATTACHMENT25: FramebufferAttachment read _COLOR_ATTACHMENT25;
public static property COLOR_ATTACHMENT26: FramebufferAttachment read _COLOR_ATTACHMENT26;
public static property COLOR_ATTACHMENT27: FramebufferAttachment read _COLOR_ATTACHMENT27;
public static property COLOR_ATTACHMENT28: FramebufferAttachment read _COLOR_ATTACHMENT28;
public static property COLOR_ATTACHMENT29: FramebufferAttachment read _COLOR_ATTACHMENT29;
public static property COLOR_ATTACHMENT30: FramebufferAttachment read _COLOR_ATTACHMENT30;
public static property COLOR_ATTACHMENT31: FramebufferAttachment read _COLOR_ATTACHMENT31;
public static property STENCIL_ATTACHMENT: FramebufferAttachment read _STENCIL_ATTACHMENT;
public function ToString: string; override;
begin
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15' else
if self.val = UInt32($8CF0) then Result := 'COLOR_ATTACHMENT16' else
if self.val = UInt32($8CF1) then Result := 'COLOR_ATTACHMENT17' else
if self.val = UInt32($8CF2) then Result := 'COLOR_ATTACHMENT18' else
if self.val = UInt32($8CF3) then Result := 'COLOR_ATTACHMENT19' else
if self.val = UInt32($8CF4) then Result := 'COLOR_ATTACHMENT20' else
if self.val = UInt32($8CF5) then Result := 'COLOR_ATTACHMENT21' else
if self.val = UInt32($8CF6) then Result := 'COLOR_ATTACHMENT22' else
if self.val = UInt32($8CF7) then Result := 'COLOR_ATTACHMENT23' else
if self.val = UInt32($8CF8) then Result := 'COLOR_ATTACHMENT24' else
if self.val = UInt32($8CF9) then Result := 'COLOR_ATTACHMENT25' else
if self.val = UInt32($8CFA) then Result := 'COLOR_ATTACHMENT26' else
if self.val = UInt32($8CFB) then Result := 'COLOR_ATTACHMENT27' else
if self.val = UInt32($8CFC) then Result := 'COLOR_ATTACHMENT28' else
if self.val = UInt32($8CFD) then Result := 'COLOR_ATTACHMENT29' else
if self.val = UInt32($8CFE) then Result := 'COLOR_ATTACHMENT30' else
if self.val = UInt32($8CFF) then Result := 'COLOR_ATTACHMENT31' else
if self.val = UInt32($8D20) then Result := 'STENCIL_ATTACHMENT' else
Result := self.val.ToString;
end;
end;
FramebufferAttachmentParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING := new FramebufferAttachmentParameterName($8210);
private static _FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT := new FramebufferAttachmentParameterName($8210);
private static _FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE := new FramebufferAttachmentParameterName($8211);
private static _FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT := new FramebufferAttachmentParameterName($8211);
private static _FRAMEBUFFER_ATTACHMENT_RED_SIZE := new FramebufferAttachmentParameterName($8212);
private static _FRAMEBUFFER_ATTACHMENT_GREEN_SIZE := new FramebufferAttachmentParameterName($8213);
private static _FRAMEBUFFER_ATTACHMENT_BLUE_SIZE := new FramebufferAttachmentParameterName($8214);
private static _FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE := new FramebufferAttachmentParameterName($8215);
private static _FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE := new FramebufferAttachmentParameterName($8216);
private static _FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE := new FramebufferAttachmentParameterName($8217);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE := new FramebufferAttachmentParameterName($8CD0);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT := new FramebufferAttachmentParameterName($8CD0);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES := new FramebufferAttachmentParameterName($8CD0);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME := new FramebufferAttachmentParameterName($8CD1);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT := new FramebufferAttachmentParameterName($8CD1);
private static _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES := new FramebufferAttachmentParameterName($8CD1);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL := new FramebufferAttachmentParameterName($8CD2);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT := new FramebufferAttachmentParameterName($8CD2);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES := new FramebufferAttachmentParameterName($8CD2);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE := new FramebufferAttachmentParameterName($8CD3);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT := new FramebufferAttachmentParameterName($8CD3);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES := new FramebufferAttachmentParameterName($8CD3);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT := new FramebufferAttachmentParameterName($8CD4);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES := new FramebufferAttachmentParameterName($8CD4);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER := new FramebufferAttachmentParameterName($8CD4);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT := new FramebufferAttachmentParameterName($8CD4);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT := new FramebufferAttachmentParameterName($8D6C);
private static _FRAMEBUFFER_ATTACHMENT_LAYERED := new FramebufferAttachmentParameterName($8DA7);
private static _FRAMEBUFFER_ATTACHMENT_LAYERED_ARB := new FramebufferAttachmentParameterName($8DA7);
private static _FRAMEBUFFER_ATTACHMENT_LAYERED_EXT := new FramebufferAttachmentParameterName($8DA7);
private static _FRAMEBUFFER_ATTACHMENT_LAYERED_OES := new FramebufferAttachmentParameterName($8DA7);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG := new FramebufferAttachmentParameterName($913F);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR := new FramebufferAttachmentParameterName($9630);
private static _FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR := new FramebufferAttachmentParameterName($9632);
public static property FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING;
public static property FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT;
public static property FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE;
public static property FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT;
public static property FRAMEBUFFER_ATTACHMENT_RED_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_RED_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_GREEN_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_BLUE_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT;
public static property FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT;
public static property FRAMEBUFFER_ATTACHMENT_LAYERED: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_LAYERED;
public static property FRAMEBUFFER_ATTACHMENT_LAYERED_ARB: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_LAYERED_ARB;
public static property FRAMEBUFFER_ATTACHMENT_LAYERED_EXT: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_LAYERED_EXT;
public static property FRAMEBUFFER_ATTACHMENT_LAYERED_OES: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_LAYERED_OES;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR;
public static property FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: FramebufferAttachmentParameterName read _FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR;
public function ToString: string; override;
begin
if self.val = UInt32($8210) then Result := 'FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING' else
if self.val = UInt32($8210) then Result := 'FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT' else
if self.val = UInt32($8211) then Result := 'FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE' else
if self.val = UInt32($8211) then Result := 'FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT' else
if self.val = UInt32($8212) then Result := 'FRAMEBUFFER_ATTACHMENT_RED_SIZE' else
if self.val = UInt32($8213) then Result := 'FRAMEBUFFER_ATTACHMENT_GREEN_SIZE' else
if self.val = UInt32($8214) then Result := 'FRAMEBUFFER_ATTACHMENT_BLUE_SIZE' else
if self.val = UInt32($8215) then Result := 'FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE' else
if self.val = UInt32($8216) then Result := 'FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE' else
if self.val = UInt32($8217) then Result := 'FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE' else
if self.val = UInt32($8CD0) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE' else
if self.val = UInt32($8CD0) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT' else
if self.val = UInt32($8CD0) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES' else
if self.val = UInt32($8CD1) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME' else
if self.val = UInt32($8CD1) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT' else
if self.val = UInt32($8CD1) then Result := 'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES' else
if self.val = UInt32($8CD2) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL' else
if self.val = UInt32($8CD2) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT' else
if self.val = UInt32($8CD2) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES' else
if self.val = UInt32($8CD3) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE' else
if self.val = UInt32($8CD3) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT' else
if self.val = UInt32($8CD3) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES' else
if self.val = UInt32($8CD4) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT' else
if self.val = UInt32($8CD4) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES' else
if self.val = UInt32($8CD4) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER' else
if self.val = UInt32($8CD4) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT' else
if self.val = UInt32($8D6C) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT' else
if self.val = UInt32($8DA7) then Result := 'FRAMEBUFFER_ATTACHMENT_LAYERED' else
if self.val = UInt32($8DA7) then Result := 'FRAMEBUFFER_ATTACHMENT_LAYERED_ARB' else
if self.val = UInt32($8DA7) then Result := 'FRAMEBUFFER_ATTACHMENT_LAYERED_EXT' else
if self.val = UInt32($8DA7) then Result := 'FRAMEBUFFER_ATTACHMENT_LAYERED_OES' else
if self.val = UInt32($913F) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG' else
if self.val = UInt32($9630) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR' else
if self.val = UInt32($9632) then Result := 'FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR' else
Result := self.val.ToString;
end;
end;
FramebufferParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAMEBUFFER_DEFAULT_WIDTH := new FramebufferParameterName($9310);
private static _FRAMEBUFFER_DEFAULT_HEIGHT := new FramebufferParameterName($9311);
private static _FRAMEBUFFER_DEFAULT_LAYERS := new FramebufferParameterName($9312);
private static _FRAMEBUFFER_DEFAULT_SAMPLES := new FramebufferParameterName($9313);
private static _FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS := new FramebufferParameterName($9314);
public static property FRAMEBUFFER_DEFAULT_WIDTH: FramebufferParameterName read _FRAMEBUFFER_DEFAULT_WIDTH;
public static property FRAMEBUFFER_DEFAULT_HEIGHT: FramebufferParameterName read _FRAMEBUFFER_DEFAULT_HEIGHT;
public static property FRAMEBUFFER_DEFAULT_LAYERS: FramebufferParameterName read _FRAMEBUFFER_DEFAULT_LAYERS;
public static property FRAMEBUFFER_DEFAULT_SAMPLES: FramebufferParameterName read _FRAMEBUFFER_DEFAULT_SAMPLES;
public static property FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS: FramebufferParameterName read _FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS;
public function ToString: string; override;
begin
if self.val = UInt32($9310) then Result := 'FRAMEBUFFER_DEFAULT_WIDTH' else
if self.val = UInt32($9311) then Result := 'FRAMEBUFFER_DEFAULT_HEIGHT' else
if self.val = UInt32($9312) then Result := 'FRAMEBUFFER_DEFAULT_LAYERS' else
if self.val = UInt32($9313) then Result := 'FRAMEBUFFER_DEFAULT_SAMPLES' else
if self.val = UInt32($9314) then Result := 'FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS' else
Result := self.val.ToString;
end;
end;
FramebufferStatus = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAMEBUFFER_UNDEFINED := new FramebufferStatus($8219);
private static _FRAMEBUFFER_COMPLETE := new FramebufferStatus($8CD5);
private static _FRAMEBUFFER_INCOMPLETE_ATTACHMENT := new FramebufferStatus($8CD6);
private static _FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT := new FramebufferStatus($8CD7);
private static _FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER := new FramebufferStatus($8CDB);
private static _FRAMEBUFFER_INCOMPLETE_READ_BUFFER := new FramebufferStatus($8CDC);
private static _FRAMEBUFFER_UNSUPPORTED := new FramebufferStatus($8CDD);
private static _FRAMEBUFFER_INCOMPLETE_MULTISAMPLE := new FramebufferStatus($8D56);
private static _FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS := new FramebufferStatus($8DA8);
public static property FRAMEBUFFER_UNDEFINED: FramebufferStatus read _FRAMEBUFFER_UNDEFINED;
public static property FRAMEBUFFER_COMPLETE: FramebufferStatus read _FRAMEBUFFER_COMPLETE;
public static property FRAMEBUFFER_INCOMPLETE_ATTACHMENT: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
public static property FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
public static property FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER;
public static property FRAMEBUFFER_INCOMPLETE_READ_BUFFER: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_READ_BUFFER;
public static property FRAMEBUFFER_UNSUPPORTED: FramebufferStatus read _FRAMEBUFFER_UNSUPPORTED;
public static property FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;
public static property FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: FramebufferStatus read _FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS;
public function ToString: string; override;
begin
if self.val = UInt32($8219) then Result := 'FRAMEBUFFER_UNDEFINED' else
if self.val = UInt32($8CD5) then Result := 'FRAMEBUFFER_COMPLETE' else
if self.val = UInt32($8CD6) then Result := 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT' else
if self.val = UInt32($8CD7) then Result := 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT' else
if self.val = UInt32($8CDB) then Result := 'FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER' else
if self.val = UInt32($8CDC) then Result := 'FRAMEBUFFER_INCOMPLETE_READ_BUFFER' else
if self.val = UInt32($8CDD) then Result := 'FRAMEBUFFER_UNSUPPORTED' else
if self.val = UInt32($8D56) then Result := 'FRAMEBUFFER_INCOMPLETE_MULTISAMPLE' else
if self.val = UInt32($8DA8) then Result := 'FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS' else
Result := self.val.ToString;
end;
end;
FramebufferTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _READ_FRAMEBUFFER := new FramebufferTarget($8CA8);
private static _DRAW_FRAMEBUFFER := new FramebufferTarget($8CA9);
private static _FRAMEBUFFER := new FramebufferTarget($8D40);
private static _FRAMEBUFFER_OES := new FramebufferTarget($8D40);
public static property READ_FRAMEBUFFER: FramebufferTarget read _READ_FRAMEBUFFER;
public static property DRAW_FRAMEBUFFER: FramebufferTarget read _DRAW_FRAMEBUFFER;
public static property FRAMEBUFFER: FramebufferTarget read _FRAMEBUFFER;
public static property FRAMEBUFFER_OES: FramebufferTarget read _FRAMEBUFFER_OES;
public function ToString: string; override;
begin
if self.val = UInt32($8CA8) then Result := 'READ_FRAMEBUFFER' else
if self.val = UInt32($8CA9) then Result := 'DRAW_FRAMEBUFFER' else
if self.val = UInt32($8D40) then Result := 'FRAMEBUFFER' else
if self.val = UInt32($8D40) then Result := 'FRAMEBUFFER_OES' else
Result := self.val.ToString;
end;
end;
FrontFaceDirection = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CW := new FrontFaceDirection($0900);
private static _CCW := new FrontFaceDirection($0901);
public static property CW: FrontFaceDirection read _CW;
public static property CCW: FrontFaceDirection read _CCW;
public function ToString: string; override;
begin
if self.val = UInt32($0900) then Result := 'CW' else
if self.val = UInt32($0901) then Result := 'CCW' else
Result := self.val.ToString;
end;
end;
GetFramebufferParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DOUBLEBUFFER := new GetFramebufferParameter($0C32);
private static _STEREO := new GetFramebufferParameter($0C33);
private static _SAMPLE_BUFFERS := new GetFramebufferParameter($80A8);
private static _SAMPLES := new GetFramebufferParameter($80A9);
private static _IMPLEMENTATION_COLOR_READ_TYPE := new GetFramebufferParameter($8B9A);
private static _IMPLEMENTATION_COLOR_READ_FORMAT := new GetFramebufferParameter($8B9B);
private static _FRAMEBUFFER_DEFAULT_WIDTH := new GetFramebufferParameter($9310);
private static _FRAMEBUFFER_DEFAULT_HEIGHT := new GetFramebufferParameter($9311);
private static _FRAMEBUFFER_DEFAULT_LAYERS := new GetFramebufferParameter($9312);
private static _FRAMEBUFFER_DEFAULT_SAMPLES := new GetFramebufferParameter($9313);
private static _FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS := new GetFramebufferParameter($9314);
public static property DOUBLEBUFFER: GetFramebufferParameter read _DOUBLEBUFFER;
public static property STEREO: GetFramebufferParameter read _STEREO;
public static property SAMPLE_BUFFERS: GetFramebufferParameter read _SAMPLE_BUFFERS;
public static property SAMPLES: GetFramebufferParameter read _SAMPLES;
public static property IMPLEMENTATION_COLOR_READ_TYPE: GetFramebufferParameter read _IMPLEMENTATION_COLOR_READ_TYPE;
public static property IMPLEMENTATION_COLOR_READ_FORMAT: GetFramebufferParameter read _IMPLEMENTATION_COLOR_READ_FORMAT;
public static property FRAMEBUFFER_DEFAULT_WIDTH: GetFramebufferParameter read _FRAMEBUFFER_DEFAULT_WIDTH;
public static property FRAMEBUFFER_DEFAULT_HEIGHT: GetFramebufferParameter read _FRAMEBUFFER_DEFAULT_HEIGHT;
public static property FRAMEBUFFER_DEFAULT_LAYERS: GetFramebufferParameter read _FRAMEBUFFER_DEFAULT_LAYERS;
public static property FRAMEBUFFER_DEFAULT_SAMPLES: GetFramebufferParameter read _FRAMEBUFFER_DEFAULT_SAMPLES;
public static property FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS: GetFramebufferParameter read _FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS;
public function ToString: string; override;
begin
if self.val = UInt32($0C32) then Result := 'DOUBLEBUFFER' else
if self.val = UInt32($0C33) then Result := 'STEREO' else
if self.val = UInt32($80A8) then Result := 'SAMPLE_BUFFERS' else
if self.val = UInt32($80A9) then Result := 'SAMPLES' else
if self.val = UInt32($8B9A) then Result := 'IMPLEMENTATION_COLOR_READ_TYPE' else
if self.val = UInt32($8B9B) then Result := 'IMPLEMENTATION_COLOR_READ_FORMAT' else
if self.val = UInt32($9310) then Result := 'FRAMEBUFFER_DEFAULT_WIDTH' else
if self.val = UInt32($9311) then Result := 'FRAMEBUFFER_DEFAULT_HEIGHT' else
if self.val = UInt32($9312) then Result := 'FRAMEBUFFER_DEFAULT_LAYERS' else
if self.val = UInt32($9313) then Result := 'FRAMEBUFFER_DEFAULT_SAMPLES' else
if self.val = UInt32($9314) then Result := 'FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS' else
Result := self.val.ToString;
end;
end;
GetMapQuery = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COEFF := new GetMapQuery($0A00);
private static _ORDER := new GetMapQuery($0A01);
private static _DOMAIN := new GetMapQuery($0A02);
public static property COEFF: GetMapQuery read _COEFF;
public static property ORDER: GetMapQuery read _ORDER;
public static property DOMAIN: GetMapQuery read _DOMAIN;
public function ToString: string; override;
begin
if self.val = UInt32($0A00) then Result := 'COEFF' else
if self.val = UInt32($0A01) then Result := 'ORDER' else
if self.val = UInt32($0A02) then Result := 'DOMAIN' else
Result := self.val.ToString;
end;
end;
GetPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CURRENT_COLOR := new GetPName($0B00);
private static _CURRENT_INDEX := new GetPName($0B01);
private static _CURRENT_NORMAL := new GetPName($0B02);
private static _CURRENT_TEXTURE_COORDS := new GetPName($0B03);
private static _CURRENT_RASTER_COLOR := new GetPName($0B04);
private static _CURRENT_RASTER_INDEX := new GetPName($0B05);
private static _CURRENT_RASTER_TEXTURE_COORDS := new GetPName($0B06);
private static _CURRENT_RASTER_POSITION := new GetPName($0B07);
private static _CURRENT_RASTER_POSITION_VALID := new GetPName($0B08);
private static _CURRENT_RASTER_DISTANCE := new GetPName($0B09);
private static _POINT_SMOOTH := new GetPName($0B10);
private static _POINT_SIZE := new GetPName($0B11);
private static _POINT_SIZE_RANGE := new GetPName($0B12);
private static _SMOOTH_POINT_SIZE_RANGE := new GetPName($0B12);
private static _POINT_SIZE_GRANULARITY := new GetPName($0B13);
private static _SMOOTH_POINT_SIZE_GRANULARITY := new GetPName($0B13);
private static _LINE_SMOOTH := new GetPName($0B20);
private static _LINE_WIDTH := new GetPName($0B21);
private static _LINE_WIDTH_RANGE := new GetPName($0B22);
private static _SMOOTH_LINE_WIDTH_RANGE := new GetPName($0B22);
private static _LINE_WIDTH_GRANULARITY := new GetPName($0B23);
private static _SMOOTH_LINE_WIDTH_GRANULARITY := new GetPName($0B23);
private static _LINE_STIPPLE := new GetPName($0B24);
private static _LINE_STIPPLE_PATTERN := new GetPName($0B25);
private static _LINE_STIPPLE_REPEAT := new GetPName($0B26);
private static _LIST_MODE := new GetPName($0B30);
private static _MAX_LIST_NESTING := new GetPName($0B31);
private static _LIST_BASE := new GetPName($0B32);
private static _LIST_INDEX := new GetPName($0B33);
private static _POLYGON_MODE := new GetPName($0B40);
private static _POLYGON_SMOOTH := new GetPName($0B41);
private static _POLYGON_STIPPLE := new GetPName($0B42);
private static _EDGE_FLAG := new GetPName($0B43);
private static _CULL_FACE := new GetPName($0B44);
private static _CULL_FACE_MODE := new GetPName($0B45);
private static _FRONT_FACE := new GetPName($0B46);
private static _LIGHTING := new GetPName($0B50);
private static _LIGHT_MODEL_LOCAL_VIEWER := new GetPName($0B51);
private static _LIGHT_MODEL_TWO_SIDE := new GetPName($0B52);
private static _LIGHT_MODEL_AMBIENT := new GetPName($0B53);
private static _SHADE_MODEL := new GetPName($0B54);
private static _COLOR_MATERIAL_FACE := new GetPName($0B55);
private static _COLOR_MATERIAL_PARAMETER := new GetPName($0B56);
private static _COLOR_MATERIAL := new GetPName($0B57);
private static _FOG := new GetPName($0B60);
private static _FOG_INDEX := new GetPName($0B61);
private static _FOG_DENSITY := new GetPName($0B62);
private static _FOG_START := new GetPName($0B63);
private static _FOG_END := new GetPName($0B64);
private static _FOG_MODE := new GetPName($0B65);
private static _FOG_COLOR := new GetPName($0B66);
private static _DEPTH_RANGE := new GetPName($0B70);
private static _DEPTH_TEST := new GetPName($0B71);
private static _DEPTH_WRITEMASK := new GetPName($0B72);
private static _DEPTH_CLEAR_VALUE := new GetPName($0B73);
private static _DEPTH_FUNC := new GetPName($0B74);
private static _ACCUM_CLEAR_VALUE := new GetPName($0B80);
private static _STENCIL_TEST := new GetPName($0B90);
private static _STENCIL_CLEAR_VALUE := new GetPName($0B91);
private static _STENCIL_FUNC := new GetPName($0B92);
private static _STENCIL_VALUE_MASK := new GetPName($0B93);
private static _STENCIL_FAIL := new GetPName($0B94);
private static _STENCIL_PASS_DEPTH_FAIL := new GetPName($0B95);
private static _STENCIL_PASS_DEPTH_PASS := new GetPName($0B96);
private static _STENCIL_REF := new GetPName($0B97);
private static _STENCIL_WRITEMASK := new GetPName($0B98);
private static _MATRIX_MODE := new GetPName($0BA0);
private static _NORMALIZE := new GetPName($0BA1);
private static _VIEWPORT := new GetPName($0BA2);
private static _MODELVIEW_STACK_DEPTH := new GetPName($0BA3);
private static _MODELVIEW0_STACK_DEPTH_EXT := new GetPName($0BA3);
private static _PROJECTION_STACK_DEPTH := new GetPName($0BA4);
private static _TEXTURE_STACK_DEPTH := new GetPName($0BA5);
private static _MODELVIEW_MATRIX := new GetPName($0BA6);
private static _MODELVIEW0_MATRIX_EXT := new GetPName($0BA6);
private static _PROJECTION_MATRIX := new GetPName($0BA7);
private static _TEXTURE_MATRIX := new GetPName($0BA8);
private static _ATTRIB_STACK_DEPTH := new GetPName($0BB0);
private static _CLIENT_ATTRIB_STACK_DEPTH := new GetPName($0BB1);
private static _ALPHA_TEST := new GetPName($0BC0);
private static _ALPHA_TEST_QCOM := new GetPName($0BC0);
private static _ALPHA_TEST_FUNC := new GetPName($0BC1);
private static _ALPHA_TEST_FUNC_QCOM := new GetPName($0BC1);
private static _ALPHA_TEST_REF := new GetPName($0BC2);
private static _ALPHA_TEST_REF_QCOM := new GetPName($0BC2);
private static _DITHER := new GetPName($0BD0);
private static _BLEND_DST := new GetPName($0BE0);
private static _BLEND_SRC := new GetPName($0BE1);
private static _BLEND := new GetPName($0BE2);
private static _LOGIC_OP_MODE := new GetPName($0BF0);
private static _INDEX_LOGIC_OP := new GetPName($0BF1);
private static _LOGIC_OP := new GetPName($0BF1);
private static _COLOR_LOGIC_OP := new GetPName($0BF2);
private static _AUX_BUFFERS := new GetPName($0C00);
private static _DRAW_BUFFER := new GetPName($0C01);
private static _DRAW_BUFFER_EXT := new GetPName($0C01);
private static _READ_BUFFER := new GetPName($0C02);
private static _READ_BUFFER_EXT := new GetPName($0C02);
private static _READ_BUFFER_NV := new GetPName($0C02);
private static _SCISSOR_BOX := new GetPName($0C10);
private static _SCISSOR_TEST := new GetPName($0C11);
private static _INDEX_CLEAR_VALUE := new GetPName($0C20);
private static _INDEX_WRITEMASK := new GetPName($0C21);
private static _COLOR_CLEAR_VALUE := new GetPName($0C22);
private static _COLOR_WRITEMASK := new GetPName($0C23);
private static _INDEX_MODE := new GetPName($0C30);
private static _RGBA_MODE := new GetPName($0C31);
private static _DOUBLEBUFFER := new GetPName($0C32);
private static _STEREO := new GetPName($0C33);
private static _RENDER_MODE := new GetPName($0C40);
private static _PERSPECTIVE_CORRECTION_HINT := new GetPName($0C50);
private static _POINT_SMOOTH_HINT := new GetPName($0C51);
private static _LINE_SMOOTH_HINT := new GetPName($0C52);
private static _POLYGON_SMOOTH_HINT := new GetPName($0C53);
private static _FOG_HINT := new GetPName($0C54);
private static _TEXTURE_GEN_S := new GetPName($0C60);
private static _TEXTURE_GEN_T := new GetPName($0C61);
private static _TEXTURE_GEN_R := new GetPName($0C62);
private static _TEXTURE_GEN_Q := new GetPName($0C63);
private static _PIXEL_MAP_I_TO_I_SIZE := new GetPName($0CB0);
private static _PIXEL_MAP_S_TO_S_SIZE := new GetPName($0CB1);
private static _PIXEL_MAP_I_TO_R_SIZE := new GetPName($0CB2);
private static _PIXEL_MAP_I_TO_G_SIZE := new GetPName($0CB3);
private static _PIXEL_MAP_I_TO_B_SIZE := new GetPName($0CB4);
private static _PIXEL_MAP_I_TO_A_SIZE := new GetPName($0CB5);
private static _PIXEL_MAP_R_TO_R_SIZE := new GetPName($0CB6);
private static _PIXEL_MAP_G_TO_G_SIZE := new GetPName($0CB7);
private static _PIXEL_MAP_B_TO_B_SIZE := new GetPName($0CB8);
private static _PIXEL_MAP_A_TO_A_SIZE := new GetPName($0CB9);
private static _UNPACK_SWAP_BYTES := new GetPName($0CF0);
private static _UNPACK_LSB_FIRST := new GetPName($0CF1);
private static _UNPACK_ROW_LENGTH := new GetPName($0CF2);
private static _UNPACK_SKIP_ROWS := new GetPName($0CF3);
private static _UNPACK_SKIP_PIXELS := new GetPName($0CF4);
private static _UNPACK_ALIGNMENT := new GetPName($0CF5);
private static _PACK_SWAP_BYTES := new GetPName($0D00);
private static _PACK_LSB_FIRST := new GetPName($0D01);
private static _PACK_ROW_LENGTH := new GetPName($0D02);
private static _PACK_SKIP_ROWS := new GetPName($0D03);
private static _PACK_SKIP_PIXELS := new GetPName($0D04);
private static _PACK_ALIGNMENT := new GetPName($0D05);
private static _MAP_COLOR := new GetPName($0D10);
private static _MAP_STENCIL := new GetPName($0D11);
private static _INDEX_SHIFT := new GetPName($0D12);
private static _INDEX_OFFSET := new GetPName($0D13);
private static _RED_SCALE := new GetPName($0D14);
private static _RED_BIAS := new GetPName($0D15);
private static _ZOOM_X := new GetPName($0D16);
private static _ZOOM_Y := new GetPName($0D17);
private static _GREEN_SCALE := new GetPName($0D18);
private static _GREEN_BIAS := new GetPName($0D19);
private static _BLUE_SCALE := new GetPName($0D1A);
private static _BLUE_BIAS := new GetPName($0D1B);
private static _ALPHA_SCALE := new GetPName($0D1C);
private static _ALPHA_BIAS := new GetPName($0D1D);
private static _DEPTH_SCALE := new GetPName($0D1E);
private static _DEPTH_BIAS := new GetPName($0D1F);
private static _MAX_EVAL_ORDER := new GetPName($0D30);
private static _MAX_LIGHTS := new GetPName($0D31);
private static _MAX_CLIP_DISTANCES := new GetPName($0D32);
private static _MAX_CLIP_PLANES := new GetPName($0D32);
private static _MAX_TEXTURE_SIZE := new GetPName($0D33);
private static _MAX_PIXEL_MAP_TABLE := new GetPName($0D34);
private static _MAX_ATTRIB_STACK_DEPTH := new GetPName($0D35);
private static _MAX_MODELVIEW_STACK_DEPTH := new GetPName($0D36);
private static _MAX_NAME_STACK_DEPTH := new GetPName($0D37);
private static _MAX_PROJECTION_STACK_DEPTH := new GetPName($0D38);
private static _MAX_TEXTURE_STACK_DEPTH := new GetPName($0D39);
private static _MAX_VIEWPORT_DIMS := new GetPName($0D3A);
private static _MAX_CLIENT_ATTRIB_STACK_DEPTH := new GetPName($0D3B);
private static _SUBPIXEL_BITS := new GetPName($0D50);
private static _INDEX_BITS := new GetPName($0D51);
private static _RED_BITS := new GetPName($0D52);
private static _GREEN_BITS := new GetPName($0D53);
private static _BLUE_BITS := new GetPName($0D54);
private static _ALPHA_BITS := new GetPName($0D55);
private static _DEPTH_BITS := new GetPName($0D56);
private static _STENCIL_BITS := new GetPName($0D57);
private static _ACCUM_RED_BITS := new GetPName($0D58);
private static _ACCUM_GREEN_BITS := new GetPName($0D59);
private static _ACCUM_BLUE_BITS := new GetPName($0D5A);
private static _ACCUM_ALPHA_BITS := new GetPName($0D5B);
private static _NAME_STACK_DEPTH := new GetPName($0D70);
private static _AUTO_NORMAL := new GetPName($0D80);
private static _MAP1_COLOR_4 := new GetPName($0D90);
private static _MAP1_INDEX := new GetPName($0D91);
private static _MAP1_NORMAL := new GetPName($0D92);
private static _MAP1_TEXTURE_COORD_1 := new GetPName($0D93);
private static _MAP1_TEXTURE_COORD_2 := new GetPName($0D94);
private static _MAP1_TEXTURE_COORD_3 := new GetPName($0D95);
private static _MAP1_TEXTURE_COORD_4 := new GetPName($0D96);
private static _MAP1_VERTEX_3 := new GetPName($0D97);
private static _MAP1_VERTEX_4 := new GetPName($0D98);
private static _MAP2_COLOR_4 := new GetPName($0DB0);
private static _MAP2_INDEX := new GetPName($0DB1);
private static _MAP2_NORMAL := new GetPName($0DB2);
private static _MAP2_TEXTURE_COORD_1 := new GetPName($0DB3);
private static _MAP2_TEXTURE_COORD_2 := new GetPName($0DB4);
private static _MAP2_TEXTURE_COORD_3 := new GetPName($0DB5);
private static _MAP2_TEXTURE_COORD_4 := new GetPName($0DB6);
private static _MAP2_VERTEX_3 := new GetPName($0DB7);
private static _MAP2_VERTEX_4 := new GetPName($0DB8);
private static _MAP1_GRID_DOMAIN := new GetPName($0DD0);
private static _MAP1_GRID_SEGMENTS := new GetPName($0DD1);
private static _MAP2_GRID_DOMAIN := new GetPName($0DD2);
private static _MAP2_GRID_SEGMENTS := new GetPName($0DD3);
private static _TEXTURE_1D := new GetPName($0DE0);
private static _TEXTURE_2D := new GetPName($0DE1);
private static _FEEDBACK_BUFFER_SIZE := new GetPName($0DF1);
private static _FEEDBACK_BUFFER_TYPE := new GetPName($0DF2);
private static _SELECTION_BUFFER_SIZE := new GetPName($0DF4);
private static _POLYGON_OFFSET_UNITS := new GetPName($2A00);
private static _POLYGON_OFFSET_POINT := new GetPName($2A01);
private static _POLYGON_OFFSET_LINE := new GetPName($2A02);
private static _CLIP_PLANE0 := new GetPName($3000);
private static _CLIP_PLANE1 := new GetPName($3001);
private static _CLIP_PLANE2 := new GetPName($3002);
private static _CLIP_PLANE3 := new GetPName($3003);
private static _CLIP_PLANE4 := new GetPName($3004);
private static _CLIP_PLANE5 := new GetPName($3005);
private static _LIGHT0 := new GetPName($4000);
private static _LIGHT1 := new GetPName($4001);
private static _LIGHT2 := new GetPName($4002);
private static _LIGHT3 := new GetPName($4003);
private static _LIGHT4 := new GetPName($4004);
private static _LIGHT5 := new GetPName($4005);
private static _LIGHT6 := new GetPName($4006);
private static _LIGHT7 := new GetPName($4007);
private static _BLEND_COLOR := new GetPName($8005);
private static _BLEND_COLOR_EXT := new GetPName($8005);
private static _BLEND_EQUATION_EXT := new GetPName($8009);
private static _BLEND_EQUATION_RGB := new GetPName($8009);
private static _PACK_CMYK_HINT_EXT := new GetPName($800E);
private static _UNPACK_CMYK_HINT_EXT := new GetPName($800F);
private static _CONVOLUTION_1D_EXT := new GetPName($8010);
private static _CONVOLUTION_2D_EXT := new GetPName($8011);
private static _SEPARABLE_2D_EXT := new GetPName($8012);
private static _POST_CONVOLUTION_RED_SCALE_EXT := new GetPName($801C);
private static _POST_CONVOLUTION_GREEN_SCALE_EXT := new GetPName($801D);
private static _POST_CONVOLUTION_BLUE_SCALE_EXT := new GetPName($801E);
private static _POST_CONVOLUTION_ALPHA_SCALE_EXT := new GetPName($801F);
private static _POST_CONVOLUTION_RED_BIAS_EXT := new GetPName($8020);
private static _POST_CONVOLUTION_GREEN_BIAS_EXT := new GetPName($8021);
private static _POST_CONVOLUTION_BLUE_BIAS_EXT := new GetPName($8022);
private static _POST_CONVOLUTION_ALPHA_BIAS_EXT := new GetPName($8023);
private static _HISTOGRAM_EXT := new GetPName($8024);
private static _MINMAX_EXT := new GetPName($802E);
private static _POLYGON_OFFSET_FILL := new GetPName($8037);
private static _POLYGON_OFFSET_FACTOR := new GetPName($8038);
private static _POLYGON_OFFSET_BIAS_EXT := new GetPName($8039);
private static _RESCALE_NORMAL_EXT := new GetPName($803A);
private static _TEXTURE_BINDING_1D := new GetPName($8068);
private static _TEXTURE_BINDING_2D := new GetPName($8069);
private static _TEXTURE_3D_BINDING_EXT := new GetPName($806A);
private static _TEXTURE_BINDING_3D := new GetPName($806A);
private static _PACK_SKIP_IMAGES := new GetPName($806B);
private static _PACK_SKIP_IMAGES_EXT := new GetPName($806B);
private static _PACK_IMAGE_HEIGHT := new GetPName($806C);
private static _PACK_IMAGE_HEIGHT_EXT := new GetPName($806C);
private static _UNPACK_SKIP_IMAGES := new GetPName($806D);
private static _UNPACK_SKIP_IMAGES_EXT := new GetPName($806D);
private static _UNPACK_IMAGE_HEIGHT := new GetPName($806E);
private static _UNPACK_IMAGE_HEIGHT_EXT := new GetPName($806E);
private static _TEXTURE_3D_EXT := new GetPName($806F);
private static _MAX_3D_TEXTURE_SIZE := new GetPName($8073);
private static _MAX_3D_TEXTURE_SIZE_EXT := new GetPName($8073);
private static _VERTEX_ARRAY := new GetPName($8074);
private static _NORMAL_ARRAY := new GetPName($8075);
private static _COLOR_ARRAY := new GetPName($8076);
private static _INDEX_ARRAY := new GetPName($8077);
private static _TEXTURE_COORD_ARRAY := new GetPName($8078);
private static _EDGE_FLAG_ARRAY := new GetPName($8079);
private static _VERTEX_ARRAY_SIZE := new GetPName($807A);
private static _VERTEX_ARRAY_TYPE := new GetPName($807B);
private static _VERTEX_ARRAY_STRIDE := new GetPName($807C);
private static _VERTEX_ARRAY_COUNT_EXT := new GetPName($807D);
private static _NORMAL_ARRAY_TYPE := new GetPName($807E);
private static _NORMAL_ARRAY_STRIDE := new GetPName($807F);
private static _NORMAL_ARRAY_COUNT_EXT := new GetPName($8080);
private static _COLOR_ARRAY_SIZE := new GetPName($8081);
private static _COLOR_ARRAY_TYPE := new GetPName($8082);
private static _COLOR_ARRAY_STRIDE := new GetPName($8083);
private static _COLOR_ARRAY_COUNT_EXT := new GetPName($8084);
private static _INDEX_ARRAY_TYPE := new GetPName($8085);
private static _INDEX_ARRAY_STRIDE := new GetPName($8086);
private static _INDEX_ARRAY_COUNT_EXT := new GetPName($8087);
private static _TEXTURE_COORD_ARRAY_SIZE := new GetPName($8088);
private static _TEXTURE_COORD_ARRAY_TYPE := new GetPName($8089);
private static _TEXTURE_COORD_ARRAY_STRIDE := new GetPName($808A);
private static _TEXTURE_COORD_ARRAY_COUNT_EXT := new GetPName($808B);
private static _EDGE_FLAG_ARRAY_STRIDE := new GetPName($808C);
private static _EDGE_FLAG_ARRAY_COUNT_EXT := new GetPName($808D);
private static _INTERLACE_SGIX := new GetPName($8094);
private static _DETAIL_TEXTURE_2D_BINDING_SGIS := new GetPName($8096);
private static _MULTISAMPLE_SGIS := new GetPName($809D);
private static _SAMPLE_ALPHA_TO_MASK_SGIS := new GetPName($809E);
private static _SAMPLE_ALPHA_TO_ONE_SGIS := new GetPName($809F);
private static _SAMPLE_MASK_SGIS := new GetPName($80A0);
private static _SAMPLE_BUFFERS := new GetPName($80A8);
private static _SAMPLE_BUFFERS_SGIS := new GetPName($80A8);
private static _SAMPLES := new GetPName($80A9);
private static _SAMPLES_SGIS := new GetPName($80A9);
private static _SAMPLE_COVERAGE_VALUE := new GetPName($80AA);
private static _SAMPLE_MASK_VALUE_SGIS := new GetPName($80AA);
private static _SAMPLE_COVERAGE_INVERT := new GetPName($80AB);
private static _SAMPLE_MASK_INVERT_SGIS := new GetPName($80AB);
private static _SAMPLE_PATTERN_SGIS := new GetPName($80AC);
private static _COLOR_MATRIX_SGI := new GetPName($80B1);
private static _COLOR_MATRIX_STACK_DEPTH_SGI := new GetPName($80B2);
private static _MAX_COLOR_MATRIX_STACK_DEPTH_SGI := new GetPName($80B3);
private static _POST_COLOR_MATRIX_RED_SCALE_SGI := new GetPName($80B4);
private static _POST_COLOR_MATRIX_GREEN_SCALE_SGI := new GetPName($80B5);
private static _POST_COLOR_MATRIX_BLUE_SCALE_SGI := new GetPName($80B6);
private static _POST_COLOR_MATRIX_ALPHA_SCALE_SGI := new GetPName($80B7);
private static _POST_COLOR_MATRIX_RED_BIAS_SGI := new GetPName($80B8);
private static _POST_COLOR_MATRIX_GREEN_BIAS_SGI := new GetPName($80B9);
private static _POST_COLOR_MATRIX_BLUE_BIAS_SGI := new GetPName($80BA);
private static _POST_COLOR_MATRIX_ALPHA_BIAS_SGI := new GetPName($80BB);
private static _TEXTURE_COLOR_TABLE_SGI := new GetPName($80BC);
private static _BLEND_DST_RGB := new GetPName($80C8);
private static _BLEND_SRC_RGB := new GetPName($80C9);
private static _BLEND_DST_ALPHA := new GetPName($80CA);
private static _BLEND_SRC_ALPHA := new GetPName($80CB);
private static _COLOR_TABLE_SGI := new GetPName($80D0);
private static _POST_CONVOLUTION_COLOR_TABLE_SGI := new GetPName($80D1);
private static _POST_COLOR_MATRIX_COLOR_TABLE_SGI := new GetPName($80D2);
private static _MAX_ELEMENTS_VERTICES := new GetPName($80E8);
private static _MAX_ELEMENTS_INDICES := new GetPName($80E9);
private static _POINT_SIZE_MIN_SGIS := new GetPName($8126);
private static _POINT_SIZE_MAX_SGIS := new GetPName($8127);
private static _POINT_FADE_THRESHOLD_SIZE := new GetPName($8128);
private static _POINT_FADE_THRESHOLD_SIZE_SGIS := new GetPName($8128);
private static _DISTANCE_ATTENUATION_SGIS := new GetPName($8129);
private static _FOG_FUNC_POINTS_SGIS := new GetPName($812B);
private static _MAX_FOG_FUNC_POINTS_SGIS := new GetPName($812C);
private static _PACK_SKIP_VOLUMES_SGIS := new GetPName($8130);
private static _PACK_IMAGE_DEPTH_SGIS := new GetPName($8131);
private static _UNPACK_SKIP_VOLUMES_SGIS := new GetPName($8132);
private static _UNPACK_IMAGE_DEPTH_SGIS := new GetPName($8133);
private static _TEXTURE_4D_SGIS := new GetPName($8134);
private static _MAX_4D_TEXTURE_SIZE_SGIS := new GetPName($8138);
private static _PIXEL_TEX_GEN_SGIX := new GetPName($8139);
private static _PIXEL_TILE_BEST_ALIGNMENT_SGIX := new GetPName($813E);
private static _PIXEL_TILE_CACHE_INCREMENT_SGIX := new GetPName($813F);
private static _PIXEL_TILE_WIDTH_SGIX := new GetPName($8140);
private static _PIXEL_TILE_HEIGHT_SGIX := new GetPName($8141);
private static _PIXEL_TILE_GRID_WIDTH_SGIX := new GetPName($8142);
private static _PIXEL_TILE_GRID_HEIGHT_SGIX := new GetPName($8143);
private static _PIXEL_TILE_GRID_DEPTH_SGIX := new GetPName($8144);
private static _PIXEL_TILE_CACHE_SIZE_SGIX := new GetPName($8145);
private static _SPRITE_SGIX := new GetPName($8148);
private static _SPRITE_MODE_SGIX := new GetPName($8149);
private static _SPRITE_AXIS_SGIX := new GetPName($814A);
private static _SPRITE_TRANSLATION_SGIX := new GetPName($814B);
private static _TEXTURE_4D_BINDING_SGIS := new GetPName($814F);
private static _MAX_CLIPMAP_DEPTH_SGIX := new GetPName($8177);
private static _MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX := new GetPName($8178);
private static _POST_TEXTURE_FILTER_BIAS_RANGE_SGIX := new GetPName($817B);
private static _POST_TEXTURE_FILTER_SCALE_RANGE_SGIX := new GetPName($817C);
private static _REFERENCE_PLANE_SGIX := new GetPName($817D);
private static _REFERENCE_PLANE_EQUATION_SGIX := new GetPName($817E);
private static _IR_INSTRUMENT1_SGIX := new GetPName($817F);
private static _INSTRUMENT_MEASUREMENTS_SGIX := new GetPName($8181);
private static _CALLIGRAPHIC_FRAGMENT_SGIX := new GetPName($8183);
private static _FRAMEZOOM_SGIX := new GetPName($818B);
private static _FRAMEZOOM_FACTOR_SGIX := new GetPName($818C);
private static _MAX_FRAMEZOOM_FACTOR_SGIX := new GetPName($818D);
private static _GENERATE_MIPMAP_HINT_SGIS := new GetPName($8192);
private static _DEFORMATIONS_MASK_SGIX := new GetPName($8196);
private static _FOG_OFFSET_SGIX := new GetPName($8198);
private static _FOG_OFFSET_VALUE_SGIX := new GetPName($8199);
private static _LIGHT_MODEL_COLOR_CONTROL := new GetPName($81F8);
private static _SHARED_TEXTURE_PALETTE_EXT := new GetPName($81FB);
private static _MAJOR_VERSION := new GetPName($821B);
private static _MINOR_VERSION := new GetPName($821C);
private static _NUM_EXTENSIONS := new GetPName($821D);
private static _CONTEXT_FLAGS := new GetPName($821E);
private static _PROGRAM_PIPELINE_BINDING := new GetPName($825A);
private static _MAX_VIEWPORTS := new GetPName($825B);
private static _VIEWPORT_SUBPIXEL_BITS := new GetPName($825C);
private static _VIEWPORT_BOUNDS_RANGE := new GetPName($825D);
private static _LAYER_PROVOKING_VERTEX := new GetPName($825E);
private static _VIEWPORT_INDEX_PROVOKING_VERTEX := new GetPName($825F);
private static _MAX_COMPUTE_UNIFORM_COMPONENTS := new GetPName($8263);
private static _MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS := new GetPName($8264);
private static _MAX_COMPUTE_ATOMIC_COUNTERS := new GetPName($8265);
private static _MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS := new GetPName($8266);
private static _MAX_DEBUG_GROUP_STACK_DEPTH := new GetPName($826C);
private static _DEBUG_GROUP_STACK_DEPTH := new GetPName($826D);
private static _MAX_UNIFORM_LOCATIONS := new GetPName($826E);
private static _VERTEX_BINDING_DIVISOR := new GetPName($82D6);
private static _VERTEX_BINDING_OFFSET := new GetPName($82D7);
private static _VERTEX_BINDING_STRIDE := new GetPName($82D8);
private static _MAX_VERTEX_ATTRIB_RELATIVE_OFFSET := new GetPName($82D9);
private static _MAX_VERTEX_ATTRIB_BINDINGS := new GetPName($82DA);
private static _MAX_LABEL_LENGTH := new GetPName($82E8);
private static _CONVOLUTION_HINT_SGIX := new GetPName($8316);
private static _ASYNC_MARKER_SGIX := new GetPName($8329);
private static _PIXEL_TEX_GEN_MODE_SGIX := new GetPName($832B);
private static _ASYNC_HISTOGRAM_SGIX := new GetPName($832C);
private static _MAX_ASYNC_HISTOGRAM_SGIX := new GetPName($832D);
private static _PIXEL_TEXTURE_SGIS := new GetPName($8353);
private static _ASYNC_TEX_IMAGE_SGIX := new GetPName($835C);
private static _ASYNC_DRAW_PIXELS_SGIX := new GetPName($835D);
private static _ASYNC_READ_PIXELS_SGIX := new GetPName($835E);
private static _MAX_ASYNC_TEX_IMAGE_SGIX := new GetPName($835F);
private static _MAX_ASYNC_DRAW_PIXELS_SGIX := new GetPName($8360);
private static _MAX_ASYNC_READ_PIXELS_SGIX := new GetPName($8361);
private static _VERTEX_PRECLIP_SGIX := new GetPName($83EE);
private static _VERTEX_PRECLIP_HINT_SGIX := new GetPName($83EF);
private static _FRAGMENT_LIGHTING_SGIX := new GetPName($8400);
private static _FRAGMENT_COLOR_MATERIAL_SGIX := new GetPName($8401);
private static _FRAGMENT_COLOR_MATERIAL_FACE_SGIX := new GetPName($8402);
private static _FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX := new GetPName($8403);
private static _MAX_FRAGMENT_LIGHTS_SGIX := new GetPName($8404);
private static _MAX_ACTIVE_LIGHTS_SGIX := new GetPName($8405);
private static _LIGHT_ENV_MODE_SGIX := new GetPName($8407);
private static _FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX := new GetPName($8408);
private static _FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX := new GetPName($8409);
private static _FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX := new GetPName($840A);
private static _FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX := new GetPName($840B);
private static _FRAGMENT_LIGHT0_SGIX := new GetPName($840C);
private static _PACK_RESAMPLE_SGIX := new GetPName($842E);
private static _UNPACK_RESAMPLE_SGIX := new GetPName($842F);
private static _ALIASED_POINT_SIZE_RANGE := new GetPName($846D);
private static _ALIASED_LINE_WIDTH_RANGE := new GetPName($846E);
private static _ACTIVE_TEXTURE := new GetPName($84E0);
private static _MAX_RENDERBUFFER_SIZE := new GetPName($84E8);
private static _TEXTURE_COMPRESSION_HINT := new GetPName($84EF);
private static _TEXTURE_BINDING_RECTANGLE := new GetPName($84F6);
private static _MAX_RECTANGLE_TEXTURE_SIZE := new GetPName($84F8);
private static _MAX_TEXTURE_LOD_BIAS := new GetPName($84FD);
private static _TEXTURE_BINDING_CUBE_MAP := new GetPName($8514);
private static _MAX_CUBE_MAP_TEXTURE_SIZE := new GetPName($851C);
private static _PACK_SUBSAMPLE_RATE_SGIX := new GetPName($85A0);
private static _UNPACK_SUBSAMPLE_RATE_SGIX := new GetPName($85A1);
private static _VERTEX_ARRAY_BINDING := new GetPName($85B5);
private static _PROGRAM_POINT_SIZE := new GetPName($8642);
private static _NUM_COMPRESSED_TEXTURE_FORMATS := new GetPName($86A2);
private static _COMPRESSED_TEXTURE_FORMATS := new GetPName($86A3);
private static _NUM_PROGRAM_BINARY_FORMATS := new GetPName($87FE);
private static _PROGRAM_BINARY_FORMATS := new GetPName($87FF);
private static _STENCIL_BACK_FUNC := new GetPName($8800);
private static _STENCIL_BACK_FAIL := new GetPName($8801);
private static _STENCIL_BACK_PASS_DEPTH_FAIL := new GetPName($8802);
private static _STENCIL_BACK_PASS_DEPTH_PASS := new GetPName($8803);
private static _MAX_DRAW_BUFFERS := new GetPName($8824);
private static _BLEND_EQUATION_ALPHA := new GetPName($883D);
private static _MAX_VERTEX_ATTRIBS := new GetPName($8869);
private static _MAX_TEXTURE_IMAGE_UNITS := new GetPName($8872);
private static _ARRAY_BUFFER_BINDING := new GetPName($8894);
private static _ELEMENT_ARRAY_BUFFER_BINDING := new GetPName($8895);
private static _PIXEL_PACK_BUFFER_BINDING := new GetPName($88ED);
private static _PIXEL_UNPACK_BUFFER_BINDING := new GetPName($88EF);
private static _MAX_DUAL_SOURCE_DRAW_BUFFERS := new GetPName($88FC);
private static _MAX_ARRAY_TEXTURE_LAYERS := new GetPName($88FF);
private static _MIN_PROGRAM_TEXEL_OFFSET := new GetPName($8904);
private static _MAX_PROGRAM_TEXEL_OFFSET := new GetPName($8905);
private static _SAMPLER_BINDING := new GetPName($8919);
private static _UNIFORM_BUFFER_BINDING := new GetPName($8A28);
private static _UNIFORM_BUFFER_START := new GetPName($8A29);
private static _UNIFORM_BUFFER_SIZE := new GetPName($8A2A);
private static _MAX_VERTEX_UNIFORM_BLOCKS := new GetPName($8A2B);
private static _MAX_GEOMETRY_UNIFORM_BLOCKS := new GetPName($8A2C);
private static _MAX_FRAGMENT_UNIFORM_BLOCKS := new GetPName($8A2D);
private static _MAX_COMBINED_UNIFORM_BLOCKS := new GetPName($8A2E);
private static _MAX_UNIFORM_BUFFER_BINDINGS := new GetPName($8A2F);
private static _MAX_UNIFORM_BLOCK_SIZE := new GetPName($8A30);
private static _MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS := new GetPName($8A31);
private static _MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS := new GetPName($8A32);
private static _MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS := new GetPName($8A33);
private static _UNIFORM_BUFFER_OFFSET_ALIGNMENT := new GetPName($8A34);
private static _MAX_FRAGMENT_UNIFORM_COMPONENTS := new GetPName($8B49);
private static _MAX_VERTEX_UNIFORM_COMPONENTS := new GetPName($8B4A);
private static _MAX_VARYING_COMPONENTS := new GetPName($8B4B);
private static _MAX_VARYING_FLOATS := new GetPName($8B4B);
private static _MAX_VERTEX_TEXTURE_IMAGE_UNITS := new GetPName($8B4C);
private static _MAX_COMBINED_TEXTURE_IMAGE_UNITS := new GetPName($8B4D);
private static _FRAGMENT_SHADER_DERIVATIVE_HINT := new GetPName($8B8B);
private static _CURRENT_PROGRAM := new GetPName($8B8D);
private static _IMPLEMENTATION_COLOR_READ_TYPE := new GetPName($8B9A);
private static _IMPLEMENTATION_COLOR_READ_FORMAT := new GetPName($8B9B);
private static _TEXTURE_BINDING_1D_ARRAY := new GetPName($8C1C);
private static _TEXTURE_BINDING_2D_ARRAY := new GetPName($8C1D);
private static _MAX_GEOMETRY_TEXTURE_IMAGE_UNITS := new GetPName($8C29);
private static _MAX_TEXTURE_BUFFER_SIZE := new GetPName($8C2B);
private static _TEXTURE_BINDING_BUFFER := new GetPName($8C2C);
private static _TRANSFORM_FEEDBACK_BUFFER_START := new GetPName($8C84);
private static _TRANSFORM_FEEDBACK_BUFFER_SIZE := new GetPName($8C85);
private static _TRANSFORM_FEEDBACK_BUFFER_BINDING := new GetPName($8C8F);
private static _STENCIL_BACK_REF := new GetPName($8CA3);
private static _STENCIL_BACK_VALUE_MASK := new GetPName($8CA4);
private static _STENCIL_BACK_WRITEMASK := new GetPName($8CA5);
private static _DRAW_FRAMEBUFFER_BINDING := new GetPName($8CA6);
private static _RENDERBUFFER_BINDING := new GetPName($8CA7);
private static _READ_FRAMEBUFFER_BINDING := new GetPName($8CAA);
private static _MAX_ELEMENT_INDEX := new GetPName($8D6B);
private static _MAX_GEOMETRY_UNIFORM_COMPONENTS := new GetPName($8DDF);
private static _NUM_SHADER_BINARY_FORMATS := new GetPName($8DF9);
private static _SHADER_COMPILER := new GetPName($8DFA);
private static _MAX_VERTEX_UNIFORM_VECTORS := new GetPName($8DFB);
private static _MAX_VARYING_VECTORS := new GetPName($8DFC);
private static _MAX_FRAGMENT_UNIFORM_VECTORS := new GetPName($8DFD);
private static _TIMESTAMP := new GetPName($8E28);
private static _PROVOKING_VERTEX := new GetPName($8E4F);
private static _MAX_SAMPLE_MASK_WORDS := new GetPName($8E59);
private static _PRIMITIVE_RESTART_INDEX := new GetPName($8F9E);
private static _MIN_MAP_BUFFER_ALIGNMENT := new GetPName($90BC);
private static _SHADER_STORAGE_BUFFER_BINDING := new GetPName($90D3);
private static _SHADER_STORAGE_BUFFER_START := new GetPName($90D4);
private static _SHADER_STORAGE_BUFFER_SIZE := new GetPName($90D5);
private static _MAX_VERTEX_SHADER_STORAGE_BLOCKS := new GetPName($90D6);
private static _MAX_GEOMETRY_SHADER_STORAGE_BLOCKS := new GetPName($90D7);
private static _MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS := new GetPName($90D8);
private static _MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS := new GetPName($90D9);
private static _MAX_FRAGMENT_SHADER_STORAGE_BLOCKS := new GetPName($90DA);
private static _MAX_COMPUTE_SHADER_STORAGE_BLOCKS := new GetPName($90DB);
private static _MAX_COMBINED_SHADER_STORAGE_BLOCKS := new GetPName($90DC);
private static _MAX_SHADER_STORAGE_BUFFER_BINDINGS := new GetPName($90DD);
private static _SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT := new GetPName($90DF);
private static _MAX_COMPUTE_WORK_GROUP_INVOCATIONS := new GetPName($90EB);
private static _DISPATCH_INDIRECT_BUFFER_BINDING := new GetPName($90EF);
private static _TEXTURE_BINDING_2D_MULTISAMPLE := new GetPName($9104);
private static _TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY := new GetPName($9105);
private static _MAX_COLOR_TEXTURE_SAMPLES := new GetPName($910E);
private static _MAX_DEPTH_TEXTURE_SAMPLES := new GetPName($910F);
private static _MAX_INTEGER_SAMPLES := new GetPName($9110);
private static _MAX_SERVER_WAIT_TIMEOUT := new GetPName($9111);
private static _MAX_VERTEX_OUTPUT_COMPONENTS := new GetPName($9122);
private static _MAX_GEOMETRY_INPUT_COMPONENTS := new GetPName($9123);
private static _MAX_GEOMETRY_OUTPUT_COMPONENTS := new GetPName($9124);
private static _MAX_FRAGMENT_INPUT_COMPONENTS := new GetPName($9125);
private static _TEXTURE_BUFFER_OFFSET_ALIGNMENT := new GetPName($919F);
private static _MAX_COMPUTE_UNIFORM_BLOCKS := new GetPName($91BB);
private static _MAX_COMPUTE_TEXTURE_IMAGE_UNITS := new GetPName($91BC);
private static _MAX_COMPUTE_WORK_GROUP_COUNT := new GetPName($91BE);
private static _MAX_COMPUTE_WORK_GROUP_SIZE := new GetPName($91BF);
private static _MAX_VERTEX_ATOMIC_COUNTERS := new GetPName($92D2);
private static _MAX_TESS_CONTROL_ATOMIC_COUNTERS := new GetPName($92D3);
private static _MAX_TESS_EVALUATION_ATOMIC_COUNTERS := new GetPName($92D4);
private static _MAX_GEOMETRY_ATOMIC_COUNTERS := new GetPName($92D5);
private static _MAX_FRAGMENT_ATOMIC_COUNTERS := new GetPName($92D6);
private static _MAX_COMBINED_ATOMIC_COUNTERS := new GetPName($92D7);
private static _MAX_FRAMEBUFFER_WIDTH := new GetPName($9315);
private static _MAX_FRAMEBUFFER_HEIGHT := new GetPName($9316);
private static _MAX_FRAMEBUFFER_LAYERS := new GetPName($9317);
private static _MAX_FRAMEBUFFER_SAMPLES := new GetPName($9318);
private static _NUM_DEVICE_UUIDS_EXT := new GetPName($9596);
private static _DEVICE_UUID_EXT := new GetPName($9597);
private static _DRIVER_UUID_EXT := new GetPName($9598);
private static _DEVICE_LUID_EXT := new GetPName($9599);
private static _DEVICE_NODE_MASK_EXT := new GetPName($959A);
public static property CURRENT_COLOR: GetPName read _CURRENT_COLOR;
public static property CURRENT_INDEX: GetPName read _CURRENT_INDEX;
public static property CURRENT_NORMAL: GetPName read _CURRENT_NORMAL;
public static property CURRENT_TEXTURE_COORDS: GetPName read _CURRENT_TEXTURE_COORDS;
public static property CURRENT_RASTER_COLOR: GetPName read _CURRENT_RASTER_COLOR;
public static property CURRENT_RASTER_INDEX: GetPName read _CURRENT_RASTER_INDEX;
public static property CURRENT_RASTER_TEXTURE_COORDS: GetPName read _CURRENT_RASTER_TEXTURE_COORDS;
public static property CURRENT_RASTER_POSITION: GetPName read _CURRENT_RASTER_POSITION;
public static property CURRENT_RASTER_POSITION_VALID: GetPName read _CURRENT_RASTER_POSITION_VALID;
public static property CURRENT_RASTER_DISTANCE: GetPName read _CURRENT_RASTER_DISTANCE;
public static property POINT_SMOOTH: GetPName read _POINT_SMOOTH;
public static property POINT_SIZE: GetPName read _POINT_SIZE;
public static property POINT_SIZE_RANGE: GetPName read _POINT_SIZE_RANGE;
public static property SMOOTH_POINT_SIZE_RANGE: GetPName read _SMOOTH_POINT_SIZE_RANGE;
public static property POINT_SIZE_GRANULARITY: GetPName read _POINT_SIZE_GRANULARITY;
public static property SMOOTH_POINT_SIZE_GRANULARITY: GetPName read _SMOOTH_POINT_SIZE_GRANULARITY;
public static property LINE_SMOOTH: GetPName read _LINE_SMOOTH;
public static property LINE_WIDTH: GetPName read _LINE_WIDTH;
public static property LINE_WIDTH_RANGE: GetPName read _LINE_WIDTH_RANGE;
public static property SMOOTH_LINE_WIDTH_RANGE: GetPName read _SMOOTH_LINE_WIDTH_RANGE;
public static property LINE_WIDTH_GRANULARITY: GetPName read _LINE_WIDTH_GRANULARITY;
public static property SMOOTH_LINE_WIDTH_GRANULARITY: GetPName read _SMOOTH_LINE_WIDTH_GRANULARITY;
public static property LINE_STIPPLE: GetPName read _LINE_STIPPLE;
public static property LINE_STIPPLE_PATTERN: GetPName read _LINE_STIPPLE_PATTERN;
public static property LINE_STIPPLE_REPEAT: GetPName read _LINE_STIPPLE_REPEAT;
public static property LIST_MODE: GetPName read _LIST_MODE;
public static property MAX_LIST_NESTING: GetPName read _MAX_LIST_NESTING;
public static property LIST_BASE: GetPName read _LIST_BASE;
public static property LIST_INDEX: GetPName read _LIST_INDEX;
public static property POLYGON_MODE: GetPName read _POLYGON_MODE;
public static property POLYGON_SMOOTH: GetPName read _POLYGON_SMOOTH;
public static property POLYGON_STIPPLE: GetPName read _POLYGON_STIPPLE;
public static property EDGE_FLAG: GetPName read _EDGE_FLAG;
public static property CULL_FACE: GetPName read _CULL_FACE;
public static property CULL_FACE_MODE: GetPName read _CULL_FACE_MODE;
public static property FRONT_FACE: GetPName read _FRONT_FACE;
public static property LIGHTING: GetPName read _LIGHTING;
public static property LIGHT_MODEL_LOCAL_VIEWER: GetPName read _LIGHT_MODEL_LOCAL_VIEWER;
public static property LIGHT_MODEL_TWO_SIDE: GetPName read _LIGHT_MODEL_TWO_SIDE;
public static property LIGHT_MODEL_AMBIENT: GetPName read _LIGHT_MODEL_AMBIENT;
public static property SHADE_MODEL: GetPName read _SHADE_MODEL;
public static property COLOR_MATERIAL_FACE: GetPName read _COLOR_MATERIAL_FACE;
public static property COLOR_MATERIAL_PARAMETER: GetPName read _COLOR_MATERIAL_PARAMETER;
public static property COLOR_MATERIAL: GetPName read _COLOR_MATERIAL;
public static property FOG: GetPName read _FOG;
public static property FOG_INDEX: GetPName read _FOG_INDEX;
public static property FOG_DENSITY: GetPName read _FOG_DENSITY;
public static property FOG_START: GetPName read _FOG_START;
public static property FOG_END: GetPName read _FOG_END;
public static property FOG_MODE: GetPName read _FOG_MODE;
public static property FOG_COLOR: GetPName read _FOG_COLOR;
public static property DEPTH_RANGE: GetPName read _DEPTH_RANGE;
public static property DEPTH_TEST: GetPName read _DEPTH_TEST;
public static property DEPTH_WRITEMASK: GetPName read _DEPTH_WRITEMASK;
public static property DEPTH_CLEAR_VALUE: GetPName read _DEPTH_CLEAR_VALUE;
public static property DEPTH_FUNC: GetPName read _DEPTH_FUNC;
public static property ACCUM_CLEAR_VALUE: GetPName read _ACCUM_CLEAR_VALUE;
public static property STENCIL_TEST: GetPName read _STENCIL_TEST;
public static property STENCIL_CLEAR_VALUE: GetPName read _STENCIL_CLEAR_VALUE;
public static property STENCIL_FUNC: GetPName read _STENCIL_FUNC;
public static property STENCIL_VALUE_MASK: GetPName read _STENCIL_VALUE_MASK;
public static property STENCIL_FAIL: GetPName read _STENCIL_FAIL;
public static property STENCIL_PASS_DEPTH_FAIL: GetPName read _STENCIL_PASS_DEPTH_FAIL;
public static property STENCIL_PASS_DEPTH_PASS: GetPName read _STENCIL_PASS_DEPTH_PASS;
public static property STENCIL_REF: GetPName read _STENCIL_REF;
public static property STENCIL_WRITEMASK: GetPName read _STENCIL_WRITEMASK;
public static property MATRIX_MODE: GetPName read _MATRIX_MODE;
public static property NORMALIZE: GetPName read _NORMALIZE;
public static property VIEWPORT: GetPName read _VIEWPORT;
public static property MODELVIEW_STACK_DEPTH: GetPName read _MODELVIEW_STACK_DEPTH;
public static property MODELVIEW0_STACK_DEPTH_EXT: GetPName read _MODELVIEW0_STACK_DEPTH_EXT;
public static property PROJECTION_STACK_DEPTH: GetPName read _PROJECTION_STACK_DEPTH;
public static property TEXTURE_STACK_DEPTH: GetPName read _TEXTURE_STACK_DEPTH;
public static property MODELVIEW_MATRIX: GetPName read _MODELVIEW_MATRIX;
public static property MODELVIEW0_MATRIX_EXT: GetPName read _MODELVIEW0_MATRIX_EXT;
public static property PROJECTION_MATRIX: GetPName read _PROJECTION_MATRIX;
public static property TEXTURE_MATRIX: GetPName read _TEXTURE_MATRIX;
public static property ATTRIB_STACK_DEPTH: GetPName read _ATTRIB_STACK_DEPTH;
public static property CLIENT_ATTRIB_STACK_DEPTH: GetPName read _CLIENT_ATTRIB_STACK_DEPTH;
public static property ALPHA_TEST: GetPName read _ALPHA_TEST;
public static property ALPHA_TEST_QCOM: GetPName read _ALPHA_TEST_QCOM;
public static property ALPHA_TEST_FUNC: GetPName read _ALPHA_TEST_FUNC;
public static property ALPHA_TEST_FUNC_QCOM: GetPName read _ALPHA_TEST_FUNC_QCOM;
public static property ALPHA_TEST_REF: GetPName read _ALPHA_TEST_REF;
public static property ALPHA_TEST_REF_QCOM: GetPName read _ALPHA_TEST_REF_QCOM;
public static property DITHER: GetPName read _DITHER;
public static property BLEND_DST: GetPName read _BLEND_DST;
public static property BLEND_SRC: GetPName read _BLEND_SRC;
public static property BLEND: GetPName read _BLEND;
public static property LOGIC_OP_MODE: GetPName read _LOGIC_OP_MODE;
public static property INDEX_LOGIC_OP: GetPName read _INDEX_LOGIC_OP;
public static property LOGIC_OP: GetPName read _LOGIC_OP;
public static property COLOR_LOGIC_OP: GetPName read _COLOR_LOGIC_OP;
public static property AUX_BUFFERS: GetPName read _AUX_BUFFERS;
public static property DRAW_BUFFER: GetPName read _DRAW_BUFFER;
public static property DRAW_BUFFER_EXT: GetPName read _DRAW_BUFFER_EXT;
public static property READ_BUFFER: GetPName read _READ_BUFFER;
public static property READ_BUFFER_EXT: GetPName read _READ_BUFFER_EXT;
public static property READ_BUFFER_NV: GetPName read _READ_BUFFER_NV;
public static property SCISSOR_BOX: GetPName read _SCISSOR_BOX;
public static property SCISSOR_TEST: GetPName read _SCISSOR_TEST;
public static property INDEX_CLEAR_VALUE: GetPName read _INDEX_CLEAR_VALUE;
public static property INDEX_WRITEMASK: GetPName read _INDEX_WRITEMASK;
public static property COLOR_CLEAR_VALUE: GetPName read _COLOR_CLEAR_VALUE;
public static property COLOR_WRITEMASK: GetPName read _COLOR_WRITEMASK;
public static property INDEX_MODE: GetPName read _INDEX_MODE;
public static property RGBA_MODE: GetPName read _RGBA_MODE;
public static property DOUBLEBUFFER: GetPName read _DOUBLEBUFFER;
public static property STEREO: GetPName read _STEREO;
public static property RENDER_MODE: GetPName read _RENDER_MODE;
public static property PERSPECTIVE_CORRECTION_HINT: GetPName read _PERSPECTIVE_CORRECTION_HINT;
public static property POINT_SMOOTH_HINT: GetPName read _POINT_SMOOTH_HINT;
public static property LINE_SMOOTH_HINT: GetPName read _LINE_SMOOTH_HINT;
public static property POLYGON_SMOOTH_HINT: GetPName read _POLYGON_SMOOTH_HINT;
public static property FOG_HINT: GetPName read _FOG_HINT;
public static property TEXTURE_GEN_S: GetPName read _TEXTURE_GEN_S;
public static property TEXTURE_GEN_T: GetPName read _TEXTURE_GEN_T;
public static property TEXTURE_GEN_R: GetPName read _TEXTURE_GEN_R;
public static property TEXTURE_GEN_Q: GetPName read _TEXTURE_GEN_Q;
public static property PIXEL_MAP_I_TO_I_SIZE: GetPName read _PIXEL_MAP_I_TO_I_SIZE;
public static property PIXEL_MAP_S_TO_S_SIZE: GetPName read _PIXEL_MAP_S_TO_S_SIZE;
public static property PIXEL_MAP_I_TO_R_SIZE: GetPName read _PIXEL_MAP_I_TO_R_SIZE;
public static property PIXEL_MAP_I_TO_G_SIZE: GetPName read _PIXEL_MAP_I_TO_G_SIZE;
public static property PIXEL_MAP_I_TO_B_SIZE: GetPName read _PIXEL_MAP_I_TO_B_SIZE;
public static property PIXEL_MAP_I_TO_A_SIZE: GetPName read _PIXEL_MAP_I_TO_A_SIZE;
public static property PIXEL_MAP_R_TO_R_SIZE: GetPName read _PIXEL_MAP_R_TO_R_SIZE;
public static property PIXEL_MAP_G_TO_G_SIZE: GetPName read _PIXEL_MAP_G_TO_G_SIZE;
public static property PIXEL_MAP_B_TO_B_SIZE: GetPName read _PIXEL_MAP_B_TO_B_SIZE;
public static property PIXEL_MAP_A_TO_A_SIZE: GetPName read _PIXEL_MAP_A_TO_A_SIZE;
public static property UNPACK_SWAP_BYTES: GetPName read _UNPACK_SWAP_BYTES;
public static property UNPACK_LSB_FIRST: GetPName read _UNPACK_LSB_FIRST;
public static property UNPACK_ROW_LENGTH: GetPName read _UNPACK_ROW_LENGTH;
public static property UNPACK_SKIP_ROWS: GetPName read _UNPACK_SKIP_ROWS;
public static property UNPACK_SKIP_PIXELS: GetPName read _UNPACK_SKIP_PIXELS;
public static property UNPACK_ALIGNMENT: GetPName read _UNPACK_ALIGNMENT;
public static property PACK_SWAP_BYTES: GetPName read _PACK_SWAP_BYTES;
public static property PACK_LSB_FIRST: GetPName read _PACK_LSB_FIRST;
public static property PACK_ROW_LENGTH: GetPName read _PACK_ROW_LENGTH;
public static property PACK_SKIP_ROWS: GetPName read _PACK_SKIP_ROWS;
public static property PACK_SKIP_PIXELS: GetPName read _PACK_SKIP_PIXELS;
public static property PACK_ALIGNMENT: GetPName read _PACK_ALIGNMENT;
public static property MAP_COLOR: GetPName read _MAP_COLOR;
public static property MAP_STENCIL: GetPName read _MAP_STENCIL;
public static property INDEX_SHIFT: GetPName read _INDEX_SHIFT;
public static property INDEX_OFFSET: GetPName read _INDEX_OFFSET;
public static property RED_SCALE: GetPName read _RED_SCALE;
public static property RED_BIAS: GetPName read _RED_BIAS;
public static property ZOOM_X: GetPName read _ZOOM_X;
public static property ZOOM_Y: GetPName read _ZOOM_Y;
public static property GREEN_SCALE: GetPName read _GREEN_SCALE;
public static property GREEN_BIAS: GetPName read _GREEN_BIAS;
public static property BLUE_SCALE: GetPName read _BLUE_SCALE;
public static property BLUE_BIAS: GetPName read _BLUE_BIAS;
public static property ALPHA_SCALE: GetPName read _ALPHA_SCALE;
public static property ALPHA_BIAS: GetPName read _ALPHA_BIAS;
public static property DEPTH_SCALE: GetPName read _DEPTH_SCALE;
public static property DEPTH_BIAS: GetPName read _DEPTH_BIAS;
public static property MAX_EVAL_ORDER: GetPName read _MAX_EVAL_ORDER;
public static property MAX_LIGHTS: GetPName read _MAX_LIGHTS;
public static property MAX_CLIP_DISTANCES: GetPName read _MAX_CLIP_DISTANCES;
public static property MAX_CLIP_PLANES: GetPName read _MAX_CLIP_PLANES;
public static property MAX_TEXTURE_SIZE: GetPName read _MAX_TEXTURE_SIZE;
public static property MAX_PIXEL_MAP_TABLE: GetPName read _MAX_PIXEL_MAP_TABLE;
public static property MAX_ATTRIB_STACK_DEPTH: GetPName read _MAX_ATTRIB_STACK_DEPTH;
public static property MAX_MODELVIEW_STACK_DEPTH: GetPName read _MAX_MODELVIEW_STACK_DEPTH;
public static property MAX_NAME_STACK_DEPTH: GetPName read _MAX_NAME_STACK_DEPTH;
public static property MAX_PROJECTION_STACK_DEPTH: GetPName read _MAX_PROJECTION_STACK_DEPTH;
public static property MAX_TEXTURE_STACK_DEPTH: GetPName read _MAX_TEXTURE_STACK_DEPTH;
public static property MAX_VIEWPORT_DIMS: GetPName read _MAX_VIEWPORT_DIMS;
public static property MAX_CLIENT_ATTRIB_STACK_DEPTH: GetPName read _MAX_CLIENT_ATTRIB_STACK_DEPTH;
public static property SUBPIXEL_BITS: GetPName read _SUBPIXEL_BITS;
public static property INDEX_BITS: GetPName read _INDEX_BITS;
public static property RED_BITS: GetPName read _RED_BITS;
public static property GREEN_BITS: GetPName read _GREEN_BITS;
public static property BLUE_BITS: GetPName read _BLUE_BITS;
public static property ALPHA_BITS: GetPName read _ALPHA_BITS;
public static property DEPTH_BITS: GetPName read _DEPTH_BITS;
public static property STENCIL_BITS: GetPName read _STENCIL_BITS;
public static property ACCUM_RED_BITS: GetPName read _ACCUM_RED_BITS;
public static property ACCUM_GREEN_BITS: GetPName read _ACCUM_GREEN_BITS;
public static property ACCUM_BLUE_BITS: GetPName read _ACCUM_BLUE_BITS;
public static property ACCUM_ALPHA_BITS: GetPName read _ACCUM_ALPHA_BITS;
public static property NAME_STACK_DEPTH: GetPName read _NAME_STACK_DEPTH;
public static property AUTO_NORMAL: GetPName read _AUTO_NORMAL;
public static property MAP1_COLOR_4: GetPName read _MAP1_COLOR_4;
public static property MAP1_INDEX: GetPName read _MAP1_INDEX;
public static property MAP1_NORMAL: GetPName read _MAP1_NORMAL;
public static property MAP1_TEXTURE_COORD_1: GetPName read _MAP1_TEXTURE_COORD_1;
public static property MAP1_TEXTURE_COORD_2: GetPName read _MAP1_TEXTURE_COORD_2;
public static property MAP1_TEXTURE_COORD_3: GetPName read _MAP1_TEXTURE_COORD_3;
public static property MAP1_TEXTURE_COORD_4: GetPName read _MAP1_TEXTURE_COORD_4;
public static property MAP1_VERTEX_3: GetPName read _MAP1_VERTEX_3;
public static property MAP1_VERTEX_4: GetPName read _MAP1_VERTEX_4;
public static property MAP2_COLOR_4: GetPName read _MAP2_COLOR_4;
public static property MAP2_INDEX: GetPName read _MAP2_INDEX;
public static property MAP2_NORMAL: GetPName read _MAP2_NORMAL;
public static property MAP2_TEXTURE_COORD_1: GetPName read _MAP2_TEXTURE_COORD_1;
public static property MAP2_TEXTURE_COORD_2: GetPName read _MAP2_TEXTURE_COORD_2;
public static property MAP2_TEXTURE_COORD_3: GetPName read _MAP2_TEXTURE_COORD_3;
public static property MAP2_TEXTURE_COORD_4: GetPName read _MAP2_TEXTURE_COORD_4;
public static property MAP2_VERTEX_3: GetPName read _MAP2_VERTEX_3;
public static property MAP2_VERTEX_4: GetPName read _MAP2_VERTEX_4;
public static property MAP1_GRID_DOMAIN: GetPName read _MAP1_GRID_DOMAIN;
public static property MAP1_GRID_SEGMENTS: GetPName read _MAP1_GRID_SEGMENTS;
public static property MAP2_GRID_DOMAIN: GetPName read _MAP2_GRID_DOMAIN;
public static property MAP2_GRID_SEGMENTS: GetPName read _MAP2_GRID_SEGMENTS;
public static property TEXTURE_1D: GetPName read _TEXTURE_1D;
public static property TEXTURE_2D: GetPName read _TEXTURE_2D;
public static property FEEDBACK_BUFFER_SIZE: GetPName read _FEEDBACK_BUFFER_SIZE;
public static property FEEDBACK_BUFFER_TYPE: GetPName read _FEEDBACK_BUFFER_TYPE;
public static property SELECTION_BUFFER_SIZE: GetPName read _SELECTION_BUFFER_SIZE;
public static property POLYGON_OFFSET_UNITS: GetPName read _POLYGON_OFFSET_UNITS;
public static property POLYGON_OFFSET_POINT: GetPName read _POLYGON_OFFSET_POINT;
public static property POLYGON_OFFSET_LINE: GetPName read _POLYGON_OFFSET_LINE;
public static property CLIP_PLANE0: GetPName read _CLIP_PLANE0;
public static property CLIP_PLANE1: GetPName read _CLIP_PLANE1;
public static property CLIP_PLANE2: GetPName read _CLIP_PLANE2;
public static property CLIP_PLANE3: GetPName read _CLIP_PLANE3;
public static property CLIP_PLANE4: GetPName read _CLIP_PLANE4;
public static property CLIP_PLANE5: GetPName read _CLIP_PLANE5;
public static property LIGHT0: GetPName read _LIGHT0;
public static property LIGHT1: GetPName read _LIGHT1;
public static property LIGHT2: GetPName read _LIGHT2;
public static property LIGHT3: GetPName read _LIGHT3;
public static property LIGHT4: GetPName read _LIGHT4;
public static property LIGHT5: GetPName read _LIGHT5;
public static property LIGHT6: GetPName read _LIGHT6;
public static property LIGHT7: GetPName read _LIGHT7;
public static property BLEND_COLOR: GetPName read _BLEND_COLOR;
public static property BLEND_COLOR_EXT: GetPName read _BLEND_COLOR_EXT;
public static property BLEND_EQUATION_EXT: GetPName read _BLEND_EQUATION_EXT;
public static property BLEND_EQUATION_RGB: GetPName read _BLEND_EQUATION_RGB;
public static property PACK_CMYK_HINT_EXT: GetPName read _PACK_CMYK_HINT_EXT;
public static property UNPACK_CMYK_HINT_EXT: GetPName read _UNPACK_CMYK_HINT_EXT;
public static property CONVOLUTION_1D_EXT: GetPName read _CONVOLUTION_1D_EXT;
public static property CONVOLUTION_2D_EXT: GetPName read _CONVOLUTION_2D_EXT;
public static property SEPARABLE_2D_EXT: GetPName read _SEPARABLE_2D_EXT;
public static property POST_CONVOLUTION_RED_SCALE_EXT: GetPName read _POST_CONVOLUTION_RED_SCALE_EXT;
public static property POST_CONVOLUTION_GREEN_SCALE_EXT: GetPName read _POST_CONVOLUTION_GREEN_SCALE_EXT;
public static property POST_CONVOLUTION_BLUE_SCALE_EXT: GetPName read _POST_CONVOLUTION_BLUE_SCALE_EXT;
public static property POST_CONVOLUTION_ALPHA_SCALE_EXT: GetPName read _POST_CONVOLUTION_ALPHA_SCALE_EXT;
public static property POST_CONVOLUTION_RED_BIAS_EXT: GetPName read _POST_CONVOLUTION_RED_BIAS_EXT;
public static property POST_CONVOLUTION_GREEN_BIAS_EXT: GetPName read _POST_CONVOLUTION_GREEN_BIAS_EXT;
public static property POST_CONVOLUTION_BLUE_BIAS_EXT: GetPName read _POST_CONVOLUTION_BLUE_BIAS_EXT;
public static property POST_CONVOLUTION_ALPHA_BIAS_EXT: GetPName read _POST_CONVOLUTION_ALPHA_BIAS_EXT;
public static property HISTOGRAM_EXT: GetPName read _HISTOGRAM_EXT;
public static property MINMAX_EXT: GetPName read _MINMAX_EXT;
public static property POLYGON_OFFSET_FILL: GetPName read _POLYGON_OFFSET_FILL;
public static property POLYGON_OFFSET_FACTOR: GetPName read _POLYGON_OFFSET_FACTOR;
public static property POLYGON_OFFSET_BIAS_EXT: GetPName read _POLYGON_OFFSET_BIAS_EXT;
public static property RESCALE_NORMAL_EXT: GetPName read _RESCALE_NORMAL_EXT;
public static property TEXTURE_BINDING_1D: GetPName read _TEXTURE_BINDING_1D;
public static property TEXTURE_BINDING_2D: GetPName read _TEXTURE_BINDING_2D;
public static property TEXTURE_3D_BINDING_EXT: GetPName read _TEXTURE_3D_BINDING_EXT;
public static property TEXTURE_BINDING_3D: GetPName read _TEXTURE_BINDING_3D;
public static property PACK_SKIP_IMAGES: GetPName read _PACK_SKIP_IMAGES;
public static property PACK_SKIP_IMAGES_EXT: GetPName read _PACK_SKIP_IMAGES_EXT;
public static property PACK_IMAGE_HEIGHT: GetPName read _PACK_IMAGE_HEIGHT;
public static property PACK_IMAGE_HEIGHT_EXT: GetPName read _PACK_IMAGE_HEIGHT_EXT;
public static property UNPACK_SKIP_IMAGES: GetPName read _UNPACK_SKIP_IMAGES;
public static property UNPACK_SKIP_IMAGES_EXT: GetPName read _UNPACK_SKIP_IMAGES_EXT;
public static property UNPACK_IMAGE_HEIGHT: GetPName read _UNPACK_IMAGE_HEIGHT;
public static property UNPACK_IMAGE_HEIGHT_EXT: GetPName read _UNPACK_IMAGE_HEIGHT_EXT;
public static property TEXTURE_3D_EXT: GetPName read _TEXTURE_3D_EXT;
public static property MAX_3D_TEXTURE_SIZE: GetPName read _MAX_3D_TEXTURE_SIZE;
public static property MAX_3D_TEXTURE_SIZE_EXT: GetPName read _MAX_3D_TEXTURE_SIZE_EXT;
public static property VERTEX_ARRAY: GetPName read _VERTEX_ARRAY;
public static property NORMAL_ARRAY: GetPName read _NORMAL_ARRAY;
public static property COLOR_ARRAY: GetPName read _COLOR_ARRAY;
public static property INDEX_ARRAY: GetPName read _INDEX_ARRAY;
public static property TEXTURE_COORD_ARRAY: GetPName read _TEXTURE_COORD_ARRAY;
public static property EDGE_FLAG_ARRAY: GetPName read _EDGE_FLAG_ARRAY;
public static property VERTEX_ARRAY_SIZE: GetPName read _VERTEX_ARRAY_SIZE;
public static property VERTEX_ARRAY_TYPE: GetPName read _VERTEX_ARRAY_TYPE;
public static property VERTEX_ARRAY_STRIDE: GetPName read _VERTEX_ARRAY_STRIDE;
public static property VERTEX_ARRAY_COUNT_EXT: GetPName read _VERTEX_ARRAY_COUNT_EXT;
public static property NORMAL_ARRAY_TYPE: GetPName read _NORMAL_ARRAY_TYPE;
public static property NORMAL_ARRAY_STRIDE: GetPName read _NORMAL_ARRAY_STRIDE;
public static property NORMAL_ARRAY_COUNT_EXT: GetPName read _NORMAL_ARRAY_COUNT_EXT;
public static property COLOR_ARRAY_SIZE: GetPName read _COLOR_ARRAY_SIZE;
public static property COLOR_ARRAY_TYPE: GetPName read _COLOR_ARRAY_TYPE;
public static property COLOR_ARRAY_STRIDE: GetPName read _COLOR_ARRAY_STRIDE;
public static property COLOR_ARRAY_COUNT_EXT: GetPName read _COLOR_ARRAY_COUNT_EXT;
public static property INDEX_ARRAY_TYPE: GetPName read _INDEX_ARRAY_TYPE;
public static property INDEX_ARRAY_STRIDE: GetPName read _INDEX_ARRAY_STRIDE;
public static property INDEX_ARRAY_COUNT_EXT: GetPName read _INDEX_ARRAY_COUNT_EXT;
public static property TEXTURE_COORD_ARRAY_SIZE: GetPName read _TEXTURE_COORD_ARRAY_SIZE;
public static property TEXTURE_COORD_ARRAY_TYPE: GetPName read _TEXTURE_COORD_ARRAY_TYPE;
public static property TEXTURE_COORD_ARRAY_STRIDE: GetPName read _TEXTURE_COORD_ARRAY_STRIDE;
public static property TEXTURE_COORD_ARRAY_COUNT_EXT: GetPName read _TEXTURE_COORD_ARRAY_COUNT_EXT;
public static property EDGE_FLAG_ARRAY_STRIDE: GetPName read _EDGE_FLAG_ARRAY_STRIDE;
public static property EDGE_FLAG_ARRAY_COUNT_EXT: GetPName read _EDGE_FLAG_ARRAY_COUNT_EXT;
public static property INTERLACE_SGIX: GetPName read _INTERLACE_SGIX;
public static property DETAIL_TEXTURE_2D_BINDING_SGIS: GetPName read _DETAIL_TEXTURE_2D_BINDING_SGIS;
public static property MULTISAMPLE_SGIS: GetPName read _MULTISAMPLE_SGIS;
public static property SAMPLE_ALPHA_TO_MASK_SGIS: GetPName read _SAMPLE_ALPHA_TO_MASK_SGIS;
public static property SAMPLE_ALPHA_TO_ONE_SGIS: GetPName read _SAMPLE_ALPHA_TO_ONE_SGIS;
public static property SAMPLE_MASK_SGIS: GetPName read _SAMPLE_MASK_SGIS;
public static property SAMPLE_BUFFERS: GetPName read _SAMPLE_BUFFERS;
public static property SAMPLE_BUFFERS_SGIS: GetPName read _SAMPLE_BUFFERS_SGIS;
public static property SAMPLES: GetPName read _SAMPLES;
public static property SAMPLES_SGIS: GetPName read _SAMPLES_SGIS;
public static property SAMPLE_COVERAGE_VALUE: GetPName read _SAMPLE_COVERAGE_VALUE;
public static property SAMPLE_MASK_VALUE_SGIS: GetPName read _SAMPLE_MASK_VALUE_SGIS;
public static property SAMPLE_COVERAGE_INVERT: GetPName read _SAMPLE_COVERAGE_INVERT;
public static property SAMPLE_MASK_INVERT_SGIS: GetPName read _SAMPLE_MASK_INVERT_SGIS;
public static property SAMPLE_PATTERN_SGIS: GetPName read _SAMPLE_PATTERN_SGIS;
public static property COLOR_MATRIX_SGI: GetPName read _COLOR_MATRIX_SGI;
public static property COLOR_MATRIX_STACK_DEPTH_SGI: GetPName read _COLOR_MATRIX_STACK_DEPTH_SGI;
public static property MAX_COLOR_MATRIX_STACK_DEPTH_SGI: GetPName read _MAX_COLOR_MATRIX_STACK_DEPTH_SGI;
public static property POST_COLOR_MATRIX_RED_SCALE_SGI: GetPName read _POST_COLOR_MATRIX_RED_SCALE_SGI;
public static property POST_COLOR_MATRIX_GREEN_SCALE_SGI: GetPName read _POST_COLOR_MATRIX_GREEN_SCALE_SGI;
public static property POST_COLOR_MATRIX_BLUE_SCALE_SGI: GetPName read _POST_COLOR_MATRIX_BLUE_SCALE_SGI;
public static property POST_COLOR_MATRIX_ALPHA_SCALE_SGI: GetPName read _POST_COLOR_MATRIX_ALPHA_SCALE_SGI;
public static property POST_COLOR_MATRIX_RED_BIAS_SGI: GetPName read _POST_COLOR_MATRIX_RED_BIAS_SGI;
public static property POST_COLOR_MATRIX_GREEN_BIAS_SGI: GetPName read _POST_COLOR_MATRIX_GREEN_BIAS_SGI;
public static property POST_COLOR_MATRIX_BLUE_BIAS_SGI: GetPName read _POST_COLOR_MATRIX_BLUE_BIAS_SGI;
public static property POST_COLOR_MATRIX_ALPHA_BIAS_SGI: GetPName read _POST_COLOR_MATRIX_ALPHA_BIAS_SGI;
public static property TEXTURE_COLOR_TABLE_SGI: GetPName read _TEXTURE_COLOR_TABLE_SGI;
public static property BLEND_DST_RGB: GetPName read _BLEND_DST_RGB;
public static property BLEND_SRC_RGB: GetPName read _BLEND_SRC_RGB;
public static property BLEND_DST_ALPHA: GetPName read _BLEND_DST_ALPHA;
public static property BLEND_SRC_ALPHA: GetPName read _BLEND_SRC_ALPHA;
public static property COLOR_TABLE_SGI: GetPName read _COLOR_TABLE_SGI;
public static property POST_CONVOLUTION_COLOR_TABLE_SGI: GetPName read _POST_CONVOLUTION_COLOR_TABLE_SGI;
public static property POST_COLOR_MATRIX_COLOR_TABLE_SGI: GetPName read _POST_COLOR_MATRIX_COLOR_TABLE_SGI;
public static property MAX_ELEMENTS_VERTICES: GetPName read _MAX_ELEMENTS_VERTICES;
public static property MAX_ELEMENTS_INDICES: GetPName read _MAX_ELEMENTS_INDICES;
public static property POINT_SIZE_MIN_SGIS: GetPName read _POINT_SIZE_MIN_SGIS;
public static property POINT_SIZE_MAX_SGIS: GetPName read _POINT_SIZE_MAX_SGIS;
public static property POINT_FADE_THRESHOLD_SIZE: GetPName read _POINT_FADE_THRESHOLD_SIZE;
public static property POINT_FADE_THRESHOLD_SIZE_SGIS: GetPName read _POINT_FADE_THRESHOLD_SIZE_SGIS;
public static property DISTANCE_ATTENUATION_SGIS: GetPName read _DISTANCE_ATTENUATION_SGIS;
public static property FOG_FUNC_POINTS_SGIS: GetPName read _FOG_FUNC_POINTS_SGIS;
public static property MAX_FOG_FUNC_POINTS_SGIS: GetPName read _MAX_FOG_FUNC_POINTS_SGIS;
public static property PACK_SKIP_VOLUMES_SGIS: GetPName read _PACK_SKIP_VOLUMES_SGIS;
public static property PACK_IMAGE_DEPTH_SGIS: GetPName read _PACK_IMAGE_DEPTH_SGIS;
public static property UNPACK_SKIP_VOLUMES_SGIS: GetPName read _UNPACK_SKIP_VOLUMES_SGIS;
public static property UNPACK_IMAGE_DEPTH_SGIS: GetPName read _UNPACK_IMAGE_DEPTH_SGIS;
public static property TEXTURE_4D_SGIS: GetPName read _TEXTURE_4D_SGIS;
public static property MAX_4D_TEXTURE_SIZE_SGIS: GetPName read _MAX_4D_TEXTURE_SIZE_SGIS;
public static property PIXEL_TEX_GEN_SGIX: GetPName read _PIXEL_TEX_GEN_SGIX;
public static property PIXEL_TILE_BEST_ALIGNMENT_SGIX: GetPName read _PIXEL_TILE_BEST_ALIGNMENT_SGIX;
public static property PIXEL_TILE_CACHE_INCREMENT_SGIX: GetPName read _PIXEL_TILE_CACHE_INCREMENT_SGIX;
public static property PIXEL_TILE_WIDTH_SGIX: GetPName read _PIXEL_TILE_WIDTH_SGIX;
public static property PIXEL_TILE_HEIGHT_SGIX: GetPName read _PIXEL_TILE_HEIGHT_SGIX;
public static property PIXEL_TILE_GRID_WIDTH_SGIX: GetPName read _PIXEL_TILE_GRID_WIDTH_SGIX;
public static property PIXEL_TILE_GRID_HEIGHT_SGIX: GetPName read _PIXEL_TILE_GRID_HEIGHT_SGIX;
public static property PIXEL_TILE_GRID_DEPTH_SGIX: GetPName read _PIXEL_TILE_GRID_DEPTH_SGIX;
public static property PIXEL_TILE_CACHE_SIZE_SGIX: GetPName read _PIXEL_TILE_CACHE_SIZE_SGIX;
public static property SPRITE_SGIX: GetPName read _SPRITE_SGIX;
public static property SPRITE_MODE_SGIX: GetPName read _SPRITE_MODE_SGIX;
public static property SPRITE_AXIS_SGIX: GetPName read _SPRITE_AXIS_SGIX;
public static property SPRITE_TRANSLATION_SGIX: GetPName read _SPRITE_TRANSLATION_SGIX;
public static property TEXTURE_4D_BINDING_SGIS: GetPName read _TEXTURE_4D_BINDING_SGIS;
public static property MAX_CLIPMAP_DEPTH_SGIX: GetPName read _MAX_CLIPMAP_DEPTH_SGIX;
public static property MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX: GetPName read _MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX;
public static property POST_TEXTURE_FILTER_BIAS_RANGE_SGIX: GetPName read _POST_TEXTURE_FILTER_BIAS_RANGE_SGIX;
public static property POST_TEXTURE_FILTER_SCALE_RANGE_SGIX: GetPName read _POST_TEXTURE_FILTER_SCALE_RANGE_SGIX;
public static property REFERENCE_PLANE_SGIX: GetPName read _REFERENCE_PLANE_SGIX;
public static property REFERENCE_PLANE_EQUATION_SGIX: GetPName read _REFERENCE_PLANE_EQUATION_SGIX;
public static property IR_INSTRUMENT1_SGIX: GetPName read _IR_INSTRUMENT1_SGIX;
public static property INSTRUMENT_MEASUREMENTS_SGIX: GetPName read _INSTRUMENT_MEASUREMENTS_SGIX;
public static property CALLIGRAPHIC_FRAGMENT_SGIX: GetPName read _CALLIGRAPHIC_FRAGMENT_SGIX;
public static property FRAMEZOOM_SGIX: GetPName read _FRAMEZOOM_SGIX;
public static property FRAMEZOOM_FACTOR_SGIX: GetPName read _FRAMEZOOM_FACTOR_SGIX;
public static property MAX_FRAMEZOOM_FACTOR_SGIX: GetPName read _MAX_FRAMEZOOM_FACTOR_SGIX;
public static property GENERATE_MIPMAP_HINT_SGIS: GetPName read _GENERATE_MIPMAP_HINT_SGIS;
public static property DEFORMATIONS_MASK_SGIX: GetPName read _DEFORMATIONS_MASK_SGIX;
public static property FOG_OFFSET_SGIX: GetPName read _FOG_OFFSET_SGIX;
public static property FOG_OFFSET_VALUE_SGIX: GetPName read _FOG_OFFSET_VALUE_SGIX;
public static property LIGHT_MODEL_COLOR_CONTROL: GetPName read _LIGHT_MODEL_COLOR_CONTROL;
public static property SHARED_TEXTURE_PALETTE_EXT: GetPName read _SHARED_TEXTURE_PALETTE_EXT;
public static property MAJOR_VERSION: GetPName read _MAJOR_VERSION;
public static property MINOR_VERSION: GetPName read _MINOR_VERSION;
public static property NUM_EXTENSIONS: GetPName read _NUM_EXTENSIONS;
public static property CONTEXT_FLAGS: GetPName read _CONTEXT_FLAGS;
public static property PROGRAM_PIPELINE_BINDING: GetPName read _PROGRAM_PIPELINE_BINDING;
public static property MAX_VIEWPORTS: GetPName read _MAX_VIEWPORTS;
public static property VIEWPORT_SUBPIXEL_BITS: GetPName read _VIEWPORT_SUBPIXEL_BITS;
public static property VIEWPORT_BOUNDS_RANGE: GetPName read _VIEWPORT_BOUNDS_RANGE;
public static property LAYER_PROVOKING_VERTEX: GetPName read _LAYER_PROVOKING_VERTEX;
public static property VIEWPORT_INDEX_PROVOKING_VERTEX: GetPName read _VIEWPORT_INDEX_PROVOKING_VERTEX;
public static property MAX_COMPUTE_UNIFORM_COMPONENTS: GetPName read _MAX_COMPUTE_UNIFORM_COMPONENTS;
public static property MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS: GetPName read _MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS;
public static property MAX_COMPUTE_ATOMIC_COUNTERS: GetPName read _MAX_COMPUTE_ATOMIC_COUNTERS;
public static property MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS: GetPName read _MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS;
public static property MAX_DEBUG_GROUP_STACK_DEPTH: GetPName read _MAX_DEBUG_GROUP_STACK_DEPTH;
public static property DEBUG_GROUP_STACK_DEPTH: GetPName read _DEBUG_GROUP_STACK_DEPTH;
public static property MAX_UNIFORM_LOCATIONS: GetPName read _MAX_UNIFORM_LOCATIONS;
public static property VERTEX_BINDING_DIVISOR: GetPName read _VERTEX_BINDING_DIVISOR;
public static property VERTEX_BINDING_OFFSET: GetPName read _VERTEX_BINDING_OFFSET;
public static property VERTEX_BINDING_STRIDE: GetPName read _VERTEX_BINDING_STRIDE;
public static property MAX_VERTEX_ATTRIB_RELATIVE_OFFSET: GetPName read _MAX_VERTEX_ATTRIB_RELATIVE_OFFSET;
public static property MAX_VERTEX_ATTRIB_BINDINGS: GetPName read _MAX_VERTEX_ATTRIB_BINDINGS;
public static property MAX_LABEL_LENGTH: GetPName read _MAX_LABEL_LENGTH;
public static property CONVOLUTION_HINT_SGIX: GetPName read _CONVOLUTION_HINT_SGIX;
public static property ASYNC_MARKER_SGIX: GetPName read _ASYNC_MARKER_SGIX;
public static property PIXEL_TEX_GEN_MODE_SGIX: GetPName read _PIXEL_TEX_GEN_MODE_SGIX;
public static property ASYNC_HISTOGRAM_SGIX: GetPName read _ASYNC_HISTOGRAM_SGIX;
public static property MAX_ASYNC_HISTOGRAM_SGIX: GetPName read _MAX_ASYNC_HISTOGRAM_SGIX;
public static property PIXEL_TEXTURE_SGIS: GetPName read _PIXEL_TEXTURE_SGIS;
public static property ASYNC_TEX_IMAGE_SGIX: GetPName read _ASYNC_TEX_IMAGE_SGIX;
public static property ASYNC_DRAW_PIXELS_SGIX: GetPName read _ASYNC_DRAW_PIXELS_SGIX;
public static property ASYNC_READ_PIXELS_SGIX: GetPName read _ASYNC_READ_PIXELS_SGIX;
public static property MAX_ASYNC_TEX_IMAGE_SGIX: GetPName read _MAX_ASYNC_TEX_IMAGE_SGIX;
public static property MAX_ASYNC_DRAW_PIXELS_SGIX: GetPName read _MAX_ASYNC_DRAW_PIXELS_SGIX;
public static property MAX_ASYNC_READ_PIXELS_SGIX: GetPName read _MAX_ASYNC_READ_PIXELS_SGIX;
public static property VERTEX_PRECLIP_SGIX: GetPName read _VERTEX_PRECLIP_SGIX;
public static property VERTEX_PRECLIP_HINT_SGIX: GetPName read _VERTEX_PRECLIP_HINT_SGIX;
public static property FRAGMENT_LIGHTING_SGIX: GetPName read _FRAGMENT_LIGHTING_SGIX;
public static property FRAGMENT_COLOR_MATERIAL_SGIX: GetPName read _FRAGMENT_COLOR_MATERIAL_SGIX;
public static property FRAGMENT_COLOR_MATERIAL_FACE_SGIX: GetPName read _FRAGMENT_COLOR_MATERIAL_FACE_SGIX;
public static property FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX: GetPName read _FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX;
public static property MAX_FRAGMENT_LIGHTS_SGIX: GetPName read _MAX_FRAGMENT_LIGHTS_SGIX;
public static property MAX_ACTIVE_LIGHTS_SGIX: GetPName read _MAX_ACTIVE_LIGHTS_SGIX;
public static property LIGHT_ENV_MODE_SGIX: GetPName read _LIGHT_ENV_MODE_SGIX;
public static property FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX: GetPName read _FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX;
public static property FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX: GetPName read _FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX;
public static property FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX: GetPName read _FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX;
public static property FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX: GetPName read _FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX;
public static property FRAGMENT_LIGHT0_SGIX: GetPName read _FRAGMENT_LIGHT0_SGIX;
public static property PACK_RESAMPLE_SGIX: GetPName read _PACK_RESAMPLE_SGIX;
public static property UNPACK_RESAMPLE_SGIX: GetPName read _UNPACK_RESAMPLE_SGIX;
public static property ALIASED_POINT_SIZE_RANGE: GetPName read _ALIASED_POINT_SIZE_RANGE;
public static property ALIASED_LINE_WIDTH_RANGE: GetPName read _ALIASED_LINE_WIDTH_RANGE;
public static property ACTIVE_TEXTURE: GetPName read _ACTIVE_TEXTURE;
public static property MAX_RENDERBUFFER_SIZE: GetPName read _MAX_RENDERBUFFER_SIZE;
public static property TEXTURE_COMPRESSION_HINT: GetPName read _TEXTURE_COMPRESSION_HINT;
public static property TEXTURE_BINDING_RECTANGLE: GetPName read _TEXTURE_BINDING_RECTANGLE;
public static property MAX_RECTANGLE_TEXTURE_SIZE: GetPName read _MAX_RECTANGLE_TEXTURE_SIZE;
public static property MAX_TEXTURE_LOD_BIAS: GetPName read _MAX_TEXTURE_LOD_BIAS;
public static property TEXTURE_BINDING_CUBE_MAP: GetPName read _TEXTURE_BINDING_CUBE_MAP;
public static property MAX_CUBE_MAP_TEXTURE_SIZE: GetPName read _MAX_CUBE_MAP_TEXTURE_SIZE;
public static property PACK_SUBSAMPLE_RATE_SGIX: GetPName read _PACK_SUBSAMPLE_RATE_SGIX;
public static property UNPACK_SUBSAMPLE_RATE_SGIX: GetPName read _UNPACK_SUBSAMPLE_RATE_SGIX;
public static property VERTEX_ARRAY_BINDING: GetPName read _VERTEX_ARRAY_BINDING;
public static property PROGRAM_POINT_SIZE: GetPName read _PROGRAM_POINT_SIZE;
public static property NUM_COMPRESSED_TEXTURE_FORMATS: GetPName read _NUM_COMPRESSED_TEXTURE_FORMATS;
public static property COMPRESSED_TEXTURE_FORMATS: GetPName read _COMPRESSED_TEXTURE_FORMATS;
public static property NUM_PROGRAM_BINARY_FORMATS: GetPName read _NUM_PROGRAM_BINARY_FORMATS;
public static property PROGRAM_BINARY_FORMATS: GetPName read _PROGRAM_BINARY_FORMATS;
public static property STENCIL_BACK_FUNC: GetPName read _STENCIL_BACK_FUNC;
public static property STENCIL_BACK_FAIL: GetPName read _STENCIL_BACK_FAIL;
public static property STENCIL_BACK_PASS_DEPTH_FAIL: GetPName read _STENCIL_BACK_PASS_DEPTH_FAIL;
public static property STENCIL_BACK_PASS_DEPTH_PASS: GetPName read _STENCIL_BACK_PASS_DEPTH_PASS;
public static property MAX_DRAW_BUFFERS: GetPName read _MAX_DRAW_BUFFERS;
public static property BLEND_EQUATION_ALPHA: GetPName read _BLEND_EQUATION_ALPHA;
public static property MAX_VERTEX_ATTRIBS: GetPName read _MAX_VERTEX_ATTRIBS;
public static property MAX_TEXTURE_IMAGE_UNITS: GetPName read _MAX_TEXTURE_IMAGE_UNITS;
public static property ARRAY_BUFFER_BINDING: GetPName read _ARRAY_BUFFER_BINDING;
public static property ELEMENT_ARRAY_BUFFER_BINDING: GetPName read _ELEMENT_ARRAY_BUFFER_BINDING;
public static property PIXEL_PACK_BUFFER_BINDING: GetPName read _PIXEL_PACK_BUFFER_BINDING;
public static property PIXEL_UNPACK_BUFFER_BINDING: GetPName read _PIXEL_UNPACK_BUFFER_BINDING;
public static property MAX_DUAL_SOURCE_DRAW_BUFFERS: GetPName read _MAX_DUAL_SOURCE_DRAW_BUFFERS;
public static property MAX_ARRAY_TEXTURE_LAYERS: GetPName read _MAX_ARRAY_TEXTURE_LAYERS;
public static property MIN_PROGRAM_TEXEL_OFFSET: GetPName read _MIN_PROGRAM_TEXEL_OFFSET;
public static property MAX_PROGRAM_TEXEL_OFFSET: GetPName read _MAX_PROGRAM_TEXEL_OFFSET;
public static property SAMPLER_BINDING: GetPName read _SAMPLER_BINDING;
public static property UNIFORM_BUFFER_BINDING: GetPName read _UNIFORM_BUFFER_BINDING;
public static property UNIFORM_BUFFER_START: GetPName read _UNIFORM_BUFFER_START;
public static property UNIFORM_BUFFER_SIZE: GetPName read _UNIFORM_BUFFER_SIZE;
public static property MAX_VERTEX_UNIFORM_BLOCKS: GetPName read _MAX_VERTEX_UNIFORM_BLOCKS;
public static property MAX_GEOMETRY_UNIFORM_BLOCKS: GetPName read _MAX_GEOMETRY_UNIFORM_BLOCKS;
public static property MAX_FRAGMENT_UNIFORM_BLOCKS: GetPName read _MAX_FRAGMENT_UNIFORM_BLOCKS;
public static property MAX_COMBINED_UNIFORM_BLOCKS: GetPName read _MAX_COMBINED_UNIFORM_BLOCKS;
public static property MAX_UNIFORM_BUFFER_BINDINGS: GetPName read _MAX_UNIFORM_BUFFER_BINDINGS;
public static property MAX_UNIFORM_BLOCK_SIZE: GetPName read _MAX_UNIFORM_BLOCK_SIZE;
public static property MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GetPName read _MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS;
public static property MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS: GetPName read _MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS;
public static property MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GetPName read _MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS;
public static property UNIFORM_BUFFER_OFFSET_ALIGNMENT: GetPName read _UNIFORM_BUFFER_OFFSET_ALIGNMENT;
public static property MAX_FRAGMENT_UNIFORM_COMPONENTS: GetPName read _MAX_FRAGMENT_UNIFORM_COMPONENTS;
public static property MAX_VERTEX_UNIFORM_COMPONENTS: GetPName read _MAX_VERTEX_UNIFORM_COMPONENTS;
public static property MAX_VARYING_COMPONENTS: GetPName read _MAX_VARYING_COMPONENTS;
public static property MAX_VARYING_FLOATS: GetPName read _MAX_VARYING_FLOATS;
public static property MAX_VERTEX_TEXTURE_IMAGE_UNITS: GetPName read _MAX_VERTEX_TEXTURE_IMAGE_UNITS;
public static property MAX_COMBINED_TEXTURE_IMAGE_UNITS: GetPName read _MAX_COMBINED_TEXTURE_IMAGE_UNITS;
public static property FRAGMENT_SHADER_DERIVATIVE_HINT: GetPName read _FRAGMENT_SHADER_DERIVATIVE_HINT;
public static property CURRENT_PROGRAM: GetPName read _CURRENT_PROGRAM;
public static property IMPLEMENTATION_COLOR_READ_TYPE: GetPName read _IMPLEMENTATION_COLOR_READ_TYPE;
public static property IMPLEMENTATION_COLOR_READ_FORMAT: GetPName read _IMPLEMENTATION_COLOR_READ_FORMAT;
public static property TEXTURE_BINDING_1D_ARRAY: GetPName read _TEXTURE_BINDING_1D_ARRAY;
public static property TEXTURE_BINDING_2D_ARRAY: GetPName read _TEXTURE_BINDING_2D_ARRAY;
public static property MAX_GEOMETRY_TEXTURE_IMAGE_UNITS: GetPName read _MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;
public static property MAX_TEXTURE_BUFFER_SIZE: GetPName read _MAX_TEXTURE_BUFFER_SIZE;
public static property TEXTURE_BINDING_BUFFER: GetPName read _TEXTURE_BINDING_BUFFER;
public static property TRANSFORM_FEEDBACK_BUFFER_START: GetPName read _TRANSFORM_FEEDBACK_BUFFER_START;
public static property TRANSFORM_FEEDBACK_BUFFER_SIZE: GetPName read _TRANSFORM_FEEDBACK_BUFFER_SIZE;
public static property TRANSFORM_FEEDBACK_BUFFER_BINDING: GetPName read _TRANSFORM_FEEDBACK_BUFFER_BINDING;
public static property STENCIL_BACK_REF: GetPName read _STENCIL_BACK_REF;
public static property STENCIL_BACK_VALUE_MASK: GetPName read _STENCIL_BACK_VALUE_MASK;
public static property STENCIL_BACK_WRITEMASK: GetPName read _STENCIL_BACK_WRITEMASK;
public static property DRAW_FRAMEBUFFER_BINDING: GetPName read _DRAW_FRAMEBUFFER_BINDING;
public static property RENDERBUFFER_BINDING: GetPName read _RENDERBUFFER_BINDING;
public static property READ_FRAMEBUFFER_BINDING: GetPName read _READ_FRAMEBUFFER_BINDING;
public static property MAX_ELEMENT_INDEX: GetPName read _MAX_ELEMENT_INDEX;
public static property MAX_GEOMETRY_UNIFORM_COMPONENTS: GetPName read _MAX_GEOMETRY_UNIFORM_COMPONENTS;
public static property NUM_SHADER_BINARY_FORMATS: GetPName read _NUM_SHADER_BINARY_FORMATS;
public static property SHADER_COMPILER: GetPName read _SHADER_COMPILER;
public static property MAX_VERTEX_UNIFORM_VECTORS: GetPName read _MAX_VERTEX_UNIFORM_VECTORS;
public static property MAX_VARYING_VECTORS: GetPName read _MAX_VARYING_VECTORS;
public static property MAX_FRAGMENT_UNIFORM_VECTORS: GetPName read _MAX_FRAGMENT_UNIFORM_VECTORS;
public static property TIMESTAMP: GetPName read _TIMESTAMP;
public static property PROVOKING_VERTEX: GetPName read _PROVOKING_VERTEX;
public static property MAX_SAMPLE_MASK_WORDS: GetPName read _MAX_SAMPLE_MASK_WORDS;
public static property PRIMITIVE_RESTART_INDEX: GetPName read _PRIMITIVE_RESTART_INDEX;
public static property MIN_MAP_BUFFER_ALIGNMENT: GetPName read _MIN_MAP_BUFFER_ALIGNMENT;
public static property SHADER_STORAGE_BUFFER_BINDING: GetPName read _SHADER_STORAGE_BUFFER_BINDING;
public static property SHADER_STORAGE_BUFFER_START: GetPName read _SHADER_STORAGE_BUFFER_START;
public static property SHADER_STORAGE_BUFFER_SIZE: GetPName read _SHADER_STORAGE_BUFFER_SIZE;
public static property MAX_VERTEX_SHADER_STORAGE_BLOCKS: GetPName read _MAX_VERTEX_SHADER_STORAGE_BLOCKS;
public static property MAX_GEOMETRY_SHADER_STORAGE_BLOCKS: GetPName read _MAX_GEOMETRY_SHADER_STORAGE_BLOCKS;
public static property MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS: GetPName read _MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS;
public static property MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS: GetPName read _MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS;
public static property MAX_FRAGMENT_SHADER_STORAGE_BLOCKS: GetPName read _MAX_FRAGMENT_SHADER_STORAGE_BLOCKS;
public static property MAX_COMPUTE_SHADER_STORAGE_BLOCKS: GetPName read _MAX_COMPUTE_SHADER_STORAGE_BLOCKS;
public static property MAX_COMBINED_SHADER_STORAGE_BLOCKS: GetPName read _MAX_COMBINED_SHADER_STORAGE_BLOCKS;
public static property MAX_SHADER_STORAGE_BUFFER_BINDINGS: GetPName read _MAX_SHADER_STORAGE_BUFFER_BINDINGS;
public static property SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT: GetPName read _SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT;
public static property MAX_COMPUTE_WORK_GROUP_INVOCATIONS: GetPName read _MAX_COMPUTE_WORK_GROUP_INVOCATIONS;
public static property DISPATCH_INDIRECT_BUFFER_BINDING: GetPName read _DISPATCH_INDIRECT_BUFFER_BINDING;
public static property TEXTURE_BINDING_2D_MULTISAMPLE: GetPName read _TEXTURE_BINDING_2D_MULTISAMPLE;
public static property TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: GetPName read _TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY;
public static property MAX_COLOR_TEXTURE_SAMPLES: GetPName read _MAX_COLOR_TEXTURE_SAMPLES;
public static property MAX_DEPTH_TEXTURE_SAMPLES: GetPName read _MAX_DEPTH_TEXTURE_SAMPLES;
public static property MAX_INTEGER_SAMPLES: GetPName read _MAX_INTEGER_SAMPLES;
public static property MAX_SERVER_WAIT_TIMEOUT: GetPName read _MAX_SERVER_WAIT_TIMEOUT;
public static property MAX_VERTEX_OUTPUT_COMPONENTS: GetPName read _MAX_VERTEX_OUTPUT_COMPONENTS;
public static property MAX_GEOMETRY_INPUT_COMPONENTS: GetPName read _MAX_GEOMETRY_INPUT_COMPONENTS;
public static property MAX_GEOMETRY_OUTPUT_COMPONENTS: GetPName read _MAX_GEOMETRY_OUTPUT_COMPONENTS;
public static property MAX_FRAGMENT_INPUT_COMPONENTS: GetPName read _MAX_FRAGMENT_INPUT_COMPONENTS;
public static property TEXTURE_BUFFER_OFFSET_ALIGNMENT: GetPName read _TEXTURE_BUFFER_OFFSET_ALIGNMENT;
public static property MAX_COMPUTE_UNIFORM_BLOCKS: GetPName read _MAX_COMPUTE_UNIFORM_BLOCKS;
public static property MAX_COMPUTE_TEXTURE_IMAGE_UNITS: GetPName read _MAX_COMPUTE_TEXTURE_IMAGE_UNITS;
public static property MAX_COMPUTE_WORK_GROUP_COUNT: GetPName read _MAX_COMPUTE_WORK_GROUP_COUNT;
public static property MAX_COMPUTE_WORK_GROUP_SIZE: GetPName read _MAX_COMPUTE_WORK_GROUP_SIZE;
public static property MAX_VERTEX_ATOMIC_COUNTERS: GetPName read _MAX_VERTEX_ATOMIC_COUNTERS;
public static property MAX_TESS_CONTROL_ATOMIC_COUNTERS: GetPName read _MAX_TESS_CONTROL_ATOMIC_COUNTERS;
public static property MAX_TESS_EVALUATION_ATOMIC_COUNTERS: GetPName read _MAX_TESS_EVALUATION_ATOMIC_COUNTERS;
public static property MAX_GEOMETRY_ATOMIC_COUNTERS: GetPName read _MAX_GEOMETRY_ATOMIC_COUNTERS;
public static property MAX_FRAGMENT_ATOMIC_COUNTERS: GetPName read _MAX_FRAGMENT_ATOMIC_COUNTERS;
public static property MAX_COMBINED_ATOMIC_COUNTERS: GetPName read _MAX_COMBINED_ATOMIC_COUNTERS;
public static property MAX_FRAMEBUFFER_WIDTH: GetPName read _MAX_FRAMEBUFFER_WIDTH;
public static property MAX_FRAMEBUFFER_HEIGHT: GetPName read _MAX_FRAMEBUFFER_HEIGHT;
public static property MAX_FRAMEBUFFER_LAYERS: GetPName read _MAX_FRAMEBUFFER_LAYERS;
public static property MAX_FRAMEBUFFER_SAMPLES: GetPName read _MAX_FRAMEBUFFER_SAMPLES;
public static property NUM_DEVICE_UUIDS_EXT: GetPName read _NUM_DEVICE_UUIDS_EXT;
public static property DEVICE_UUID_EXT: GetPName read _DEVICE_UUID_EXT;
public static property DRIVER_UUID_EXT: GetPName read _DRIVER_UUID_EXT;
public static property DEVICE_LUID_EXT: GetPName read _DEVICE_LUID_EXT;
public static property DEVICE_NODE_MASK_EXT: GetPName read _DEVICE_NODE_MASK_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($0B00) then Result := 'CURRENT_COLOR' else
if self.val = UInt32($0B01) then Result := 'CURRENT_INDEX' else
if self.val = UInt32($0B02) then Result := 'CURRENT_NORMAL' else
if self.val = UInt32($0B03) then Result := 'CURRENT_TEXTURE_COORDS' else
if self.val = UInt32($0B04) then Result := 'CURRENT_RASTER_COLOR' else
if self.val = UInt32($0B05) then Result := 'CURRENT_RASTER_INDEX' else
if self.val = UInt32($0B06) then Result := 'CURRENT_RASTER_TEXTURE_COORDS' else
if self.val = UInt32($0B07) then Result := 'CURRENT_RASTER_POSITION' else
if self.val = UInt32($0B08) then Result := 'CURRENT_RASTER_POSITION_VALID' else
if self.val = UInt32($0B09) then Result := 'CURRENT_RASTER_DISTANCE' else
if self.val = UInt32($0B10) then Result := 'POINT_SMOOTH' else
if self.val = UInt32($0B11) then Result := 'POINT_SIZE' else
if self.val = UInt32($0B12) then Result := 'POINT_SIZE_RANGE' else
if self.val = UInt32($0B12) then Result := 'SMOOTH_POINT_SIZE_RANGE' else
if self.val = UInt32($0B13) then Result := 'POINT_SIZE_GRANULARITY' else
if self.val = UInt32($0B13) then Result := 'SMOOTH_POINT_SIZE_GRANULARITY' else
if self.val = UInt32($0B20) then Result := 'LINE_SMOOTH' else
if self.val = UInt32($0B21) then Result := 'LINE_WIDTH' else
if self.val = UInt32($0B22) then Result := 'LINE_WIDTH_RANGE' else
if self.val = UInt32($0B22) then Result := 'SMOOTH_LINE_WIDTH_RANGE' else
if self.val = UInt32($0B23) then Result := 'LINE_WIDTH_GRANULARITY' else
if self.val = UInt32($0B23) then Result := 'SMOOTH_LINE_WIDTH_GRANULARITY' else
if self.val = UInt32($0B24) then Result := 'LINE_STIPPLE' else
if self.val = UInt32($0B25) then Result := 'LINE_STIPPLE_PATTERN' else
if self.val = UInt32($0B26) then Result := 'LINE_STIPPLE_REPEAT' else
if self.val = UInt32($0B30) then Result := 'LIST_MODE' else
if self.val = UInt32($0B31) then Result := 'MAX_LIST_NESTING' else
if self.val = UInt32($0B32) then Result := 'LIST_BASE' else
if self.val = UInt32($0B33) then Result := 'LIST_INDEX' else
if self.val = UInt32($0B40) then Result := 'POLYGON_MODE' else
if self.val = UInt32($0B41) then Result := 'POLYGON_SMOOTH' else
if self.val = UInt32($0B42) then Result := 'POLYGON_STIPPLE' else
if self.val = UInt32($0B43) then Result := 'EDGE_FLAG' else
if self.val = UInt32($0B44) then Result := 'CULL_FACE' else
if self.val = UInt32($0B45) then Result := 'CULL_FACE_MODE' else
if self.val = UInt32($0B46) then Result := 'FRONT_FACE' else
if self.val = UInt32($0B50) then Result := 'LIGHTING' else
if self.val = UInt32($0B51) then Result := 'LIGHT_MODEL_LOCAL_VIEWER' else
if self.val = UInt32($0B52) then Result := 'LIGHT_MODEL_TWO_SIDE' else
if self.val = UInt32($0B53) then Result := 'LIGHT_MODEL_AMBIENT' else
if self.val = UInt32($0B54) then Result := 'SHADE_MODEL' else
if self.val = UInt32($0B55) then Result := 'COLOR_MATERIAL_FACE' else
if self.val = UInt32($0B56) then Result := 'COLOR_MATERIAL_PARAMETER' else
if self.val = UInt32($0B57) then Result := 'COLOR_MATERIAL' else
if self.val = UInt32($0B60) then Result := 'FOG' else
if self.val = UInt32($0B61) then Result := 'FOG_INDEX' else
if self.val = UInt32($0B62) then Result := 'FOG_DENSITY' else
if self.val = UInt32($0B63) then Result := 'FOG_START' else
if self.val = UInt32($0B64) then Result := 'FOG_END' else
if self.val = UInt32($0B65) then Result := 'FOG_MODE' else
if self.val = UInt32($0B66) then Result := 'FOG_COLOR' else
if self.val = UInt32($0B70) then Result := 'DEPTH_RANGE' else
if self.val = UInt32($0B71) then Result := 'DEPTH_TEST' else
if self.val = UInt32($0B72) then Result := 'DEPTH_WRITEMASK' else
if self.val = UInt32($0B73) then Result := 'DEPTH_CLEAR_VALUE' else
if self.val = UInt32($0B74) then Result := 'DEPTH_FUNC' else
if self.val = UInt32($0B80) then Result := 'ACCUM_CLEAR_VALUE' else
if self.val = UInt32($0B90) then Result := 'STENCIL_TEST' else
if self.val = UInt32($0B91) then Result := 'STENCIL_CLEAR_VALUE' else
if self.val = UInt32($0B92) then Result := 'STENCIL_FUNC' else
if self.val = UInt32($0B93) then Result := 'STENCIL_VALUE_MASK' else
if self.val = UInt32($0B94) then Result := 'STENCIL_FAIL' else
if self.val = UInt32($0B95) then Result := 'STENCIL_PASS_DEPTH_FAIL' else
if self.val = UInt32($0B96) then Result := 'STENCIL_PASS_DEPTH_PASS' else
if self.val = UInt32($0B97) then Result := 'STENCIL_REF' else
if self.val = UInt32($0B98) then Result := 'STENCIL_WRITEMASK' else
if self.val = UInt32($0BA0) then Result := 'MATRIX_MODE' else
if self.val = UInt32($0BA1) then Result := 'NORMALIZE' else
if self.val = UInt32($0BA2) then Result := 'VIEWPORT' else
if self.val = UInt32($0BA3) then Result := 'MODELVIEW_STACK_DEPTH' else
if self.val = UInt32($0BA3) then Result := 'MODELVIEW0_STACK_DEPTH_EXT' else
if self.val = UInt32($0BA4) then Result := 'PROJECTION_STACK_DEPTH' else
if self.val = UInt32($0BA5) then Result := 'TEXTURE_STACK_DEPTH' else
if self.val = UInt32($0BA6) then Result := 'MODELVIEW_MATRIX' else
if self.val = UInt32($0BA6) then Result := 'MODELVIEW0_MATRIX_EXT' else
if self.val = UInt32($0BA7) then Result := 'PROJECTION_MATRIX' else
if self.val = UInt32($0BA8) then Result := 'TEXTURE_MATRIX' else
if self.val = UInt32($0BB0) then Result := 'ATTRIB_STACK_DEPTH' else
if self.val = UInt32($0BB1) then Result := 'CLIENT_ATTRIB_STACK_DEPTH' else
if self.val = UInt32($0BC0) then Result := 'ALPHA_TEST' else
if self.val = UInt32($0BC0) then Result := 'ALPHA_TEST_QCOM' else
if self.val = UInt32($0BC1) then Result := 'ALPHA_TEST_FUNC' else
if self.val = UInt32($0BC1) then Result := 'ALPHA_TEST_FUNC_QCOM' else
if self.val = UInt32($0BC2) then Result := 'ALPHA_TEST_REF' else
if self.val = UInt32($0BC2) then Result := 'ALPHA_TEST_REF_QCOM' else
if self.val = UInt32($0BD0) then Result := 'DITHER' else
if self.val = UInt32($0BE0) then Result := 'BLEND_DST' else
if self.val = UInt32($0BE1) then Result := 'BLEND_SRC' else
if self.val = UInt32($0BE2) then Result := 'BLEND' else
if self.val = UInt32($0BF0) then Result := 'LOGIC_OP_MODE' else
if self.val = UInt32($0BF1) then Result := 'INDEX_LOGIC_OP' else
if self.val = UInt32($0BF1) then Result := 'LOGIC_OP' else
if self.val = UInt32($0BF2) then Result := 'COLOR_LOGIC_OP' else
if self.val = UInt32($0C00) then Result := 'AUX_BUFFERS' else
if self.val = UInt32($0C01) then Result := 'DRAW_BUFFER' else
if self.val = UInt32($0C01) then Result := 'DRAW_BUFFER_EXT' else
if self.val = UInt32($0C02) then Result := 'READ_BUFFER' else
if self.val = UInt32($0C02) then Result := 'READ_BUFFER_EXT' else
if self.val = UInt32($0C02) then Result := 'READ_BUFFER_NV' else
if self.val = UInt32($0C10) then Result := 'SCISSOR_BOX' else
if self.val = UInt32($0C11) then Result := 'SCISSOR_TEST' else
if self.val = UInt32($0C20) then Result := 'INDEX_CLEAR_VALUE' else
if self.val = UInt32($0C21) then Result := 'INDEX_WRITEMASK' else
if self.val = UInt32($0C22) then Result := 'COLOR_CLEAR_VALUE' else
if self.val = UInt32($0C23) then Result := 'COLOR_WRITEMASK' else
if self.val = UInt32($0C30) then Result := 'INDEX_MODE' else
if self.val = UInt32($0C31) then Result := 'RGBA_MODE' else
if self.val = UInt32($0C32) then Result := 'DOUBLEBUFFER' else
if self.val = UInt32($0C33) then Result := 'STEREO' else
if self.val = UInt32($0C40) then Result := 'RENDER_MODE' else
if self.val = UInt32($0C50) then Result := 'PERSPECTIVE_CORRECTION_HINT' else
if self.val = UInt32($0C51) then Result := 'POINT_SMOOTH_HINT' else
if self.val = UInt32($0C52) then Result := 'LINE_SMOOTH_HINT' else
if self.val = UInt32($0C53) then Result := 'POLYGON_SMOOTH_HINT' else
if self.val = UInt32($0C54) then Result := 'FOG_HINT' else
if self.val = UInt32($0C60) then Result := 'TEXTURE_GEN_S' else
if self.val = UInt32($0C61) then Result := 'TEXTURE_GEN_T' else
if self.val = UInt32($0C62) then Result := 'TEXTURE_GEN_R' else
if self.val = UInt32($0C63) then Result := 'TEXTURE_GEN_Q' else
if self.val = UInt32($0CB0) then Result := 'PIXEL_MAP_I_TO_I_SIZE' else
if self.val = UInt32($0CB1) then Result := 'PIXEL_MAP_S_TO_S_SIZE' else
if self.val = UInt32($0CB2) then Result := 'PIXEL_MAP_I_TO_R_SIZE' else
if self.val = UInt32($0CB3) then Result := 'PIXEL_MAP_I_TO_G_SIZE' else
if self.val = UInt32($0CB4) then Result := 'PIXEL_MAP_I_TO_B_SIZE' else
if self.val = UInt32($0CB5) then Result := 'PIXEL_MAP_I_TO_A_SIZE' else
if self.val = UInt32($0CB6) then Result := 'PIXEL_MAP_R_TO_R_SIZE' else
if self.val = UInt32($0CB7) then Result := 'PIXEL_MAP_G_TO_G_SIZE' else
if self.val = UInt32($0CB8) then Result := 'PIXEL_MAP_B_TO_B_SIZE' else
if self.val = UInt32($0CB9) then Result := 'PIXEL_MAP_A_TO_A_SIZE' else
if self.val = UInt32($0CF0) then Result := 'UNPACK_SWAP_BYTES' else
if self.val = UInt32($0CF1) then Result := 'UNPACK_LSB_FIRST' else
if self.val = UInt32($0CF2) then Result := 'UNPACK_ROW_LENGTH' else
if self.val = UInt32($0CF3) then Result := 'UNPACK_SKIP_ROWS' else
if self.val = UInt32($0CF4) then Result := 'UNPACK_SKIP_PIXELS' else
if self.val = UInt32($0CF5) then Result := 'UNPACK_ALIGNMENT' else
if self.val = UInt32($0D00) then Result := 'PACK_SWAP_BYTES' else
if self.val = UInt32($0D01) then Result := 'PACK_LSB_FIRST' else
if self.val = UInt32($0D02) then Result := 'PACK_ROW_LENGTH' else
if self.val = UInt32($0D03) then Result := 'PACK_SKIP_ROWS' else
if self.val = UInt32($0D04) then Result := 'PACK_SKIP_PIXELS' else
if self.val = UInt32($0D05) then Result := 'PACK_ALIGNMENT' else
if self.val = UInt32($0D10) then Result := 'MAP_COLOR' else
if self.val = UInt32($0D11) then Result := 'MAP_STENCIL' else
if self.val = UInt32($0D12) then Result := 'INDEX_SHIFT' else
if self.val = UInt32($0D13) then Result := 'INDEX_OFFSET' else
if self.val = UInt32($0D14) then Result := 'RED_SCALE' else
if self.val = UInt32($0D15) then Result := 'RED_BIAS' else
if self.val = UInt32($0D16) then Result := 'ZOOM_X' else
if self.val = UInt32($0D17) then Result := 'ZOOM_Y' else
if self.val = UInt32($0D18) then Result := 'GREEN_SCALE' else
if self.val = UInt32($0D19) then Result := 'GREEN_BIAS' else
if self.val = UInt32($0D1A) then Result := 'BLUE_SCALE' else
if self.val = UInt32($0D1B) then Result := 'BLUE_BIAS' else
if self.val = UInt32($0D1C) then Result := 'ALPHA_SCALE' else
if self.val = UInt32($0D1D) then Result := 'ALPHA_BIAS' else
if self.val = UInt32($0D1E) then Result := 'DEPTH_SCALE' else
if self.val = UInt32($0D1F) then Result := 'DEPTH_BIAS' else
if self.val = UInt32($0D30) then Result := 'MAX_EVAL_ORDER' else
if self.val = UInt32($0D31) then Result := 'MAX_LIGHTS' else
if self.val = UInt32($0D32) then Result := 'MAX_CLIP_DISTANCES' else
if self.val = UInt32($0D32) then Result := 'MAX_CLIP_PLANES' else
if self.val = UInt32($0D33) then Result := 'MAX_TEXTURE_SIZE' else
if self.val = UInt32($0D34) then Result := 'MAX_PIXEL_MAP_TABLE' else
if self.val = UInt32($0D35) then Result := 'MAX_ATTRIB_STACK_DEPTH' else
if self.val = UInt32($0D36) then Result := 'MAX_MODELVIEW_STACK_DEPTH' else
if self.val = UInt32($0D37) then Result := 'MAX_NAME_STACK_DEPTH' else
if self.val = UInt32($0D38) then Result := 'MAX_PROJECTION_STACK_DEPTH' else
if self.val = UInt32($0D39) then Result := 'MAX_TEXTURE_STACK_DEPTH' else
if self.val = UInt32($0D3A) then Result := 'MAX_VIEWPORT_DIMS' else
if self.val = UInt32($0D3B) then Result := 'MAX_CLIENT_ATTRIB_STACK_DEPTH' else
if self.val = UInt32($0D50) then Result := 'SUBPIXEL_BITS' else
if self.val = UInt32($0D51) then Result := 'INDEX_BITS' else
if self.val = UInt32($0D52) then Result := 'RED_BITS' else
if self.val = UInt32($0D53) then Result := 'GREEN_BITS' else
if self.val = UInt32($0D54) then Result := 'BLUE_BITS' else
if self.val = UInt32($0D55) then Result := 'ALPHA_BITS' else
if self.val = UInt32($0D56) then Result := 'DEPTH_BITS' else
if self.val = UInt32($0D57) then Result := 'STENCIL_BITS' else
if self.val = UInt32($0D58) then Result := 'ACCUM_RED_BITS' else
if self.val = UInt32($0D59) then Result := 'ACCUM_GREEN_BITS' else
if self.val = UInt32($0D5A) then Result := 'ACCUM_BLUE_BITS' else
if self.val = UInt32($0D5B) then Result := 'ACCUM_ALPHA_BITS' else
if self.val = UInt32($0D70) then Result := 'NAME_STACK_DEPTH' else
if self.val = UInt32($0D80) then Result := 'AUTO_NORMAL' else
if self.val = UInt32($0D90) then Result := 'MAP1_COLOR_4' else
if self.val = UInt32($0D91) then Result := 'MAP1_INDEX' else
if self.val = UInt32($0D92) then Result := 'MAP1_NORMAL' else
if self.val = UInt32($0D93) then Result := 'MAP1_TEXTURE_COORD_1' else
if self.val = UInt32($0D94) then Result := 'MAP1_TEXTURE_COORD_2' else
if self.val = UInt32($0D95) then Result := 'MAP1_TEXTURE_COORD_3' else
if self.val = UInt32($0D96) then Result := 'MAP1_TEXTURE_COORD_4' else
if self.val = UInt32($0D97) then Result := 'MAP1_VERTEX_3' else
if self.val = UInt32($0D98) then Result := 'MAP1_VERTEX_4' else
if self.val = UInt32($0DB0) then Result := 'MAP2_COLOR_4' else
if self.val = UInt32($0DB1) then Result := 'MAP2_INDEX' else
if self.val = UInt32($0DB2) then Result := 'MAP2_NORMAL' else
if self.val = UInt32($0DB3) then Result := 'MAP2_TEXTURE_COORD_1' else
if self.val = UInt32($0DB4) then Result := 'MAP2_TEXTURE_COORD_2' else
if self.val = UInt32($0DB5) then Result := 'MAP2_TEXTURE_COORD_3' else
if self.val = UInt32($0DB6) then Result := 'MAP2_TEXTURE_COORD_4' else
if self.val = UInt32($0DB7) then Result := 'MAP2_VERTEX_3' else
if self.val = UInt32($0DB8) then Result := 'MAP2_VERTEX_4' else
if self.val = UInt32($0DD0) then Result := 'MAP1_GRID_DOMAIN' else
if self.val = UInt32($0DD1) then Result := 'MAP1_GRID_SEGMENTS' else
if self.val = UInt32($0DD2) then Result := 'MAP2_GRID_DOMAIN' else
if self.val = UInt32($0DD3) then Result := 'MAP2_GRID_SEGMENTS' else
if self.val = UInt32($0DE0) then Result := 'TEXTURE_1D' else
if self.val = UInt32($0DE1) then Result := 'TEXTURE_2D' else
if self.val = UInt32($0DF1) then Result := 'FEEDBACK_BUFFER_SIZE' else
if self.val = UInt32($0DF2) then Result := 'FEEDBACK_BUFFER_TYPE' else
if self.val = UInt32($0DF4) then Result := 'SELECTION_BUFFER_SIZE' else
if self.val = UInt32($2A00) then Result := 'POLYGON_OFFSET_UNITS' else
if self.val = UInt32($2A01) then Result := 'POLYGON_OFFSET_POINT' else
if self.val = UInt32($2A02) then Result := 'POLYGON_OFFSET_LINE' else
if self.val = UInt32($3000) then Result := 'CLIP_PLANE0' else
if self.val = UInt32($3001) then Result := 'CLIP_PLANE1' else
if self.val = UInt32($3002) then Result := 'CLIP_PLANE2' else
if self.val = UInt32($3003) then Result := 'CLIP_PLANE3' else
if self.val = UInt32($3004) then Result := 'CLIP_PLANE4' else
if self.val = UInt32($3005) then Result := 'CLIP_PLANE5' else
if self.val = UInt32($4000) then Result := 'LIGHT0' else
if self.val = UInt32($4001) then Result := 'LIGHT1' else
if self.val = UInt32($4002) then Result := 'LIGHT2' else
if self.val = UInt32($4003) then Result := 'LIGHT3' else
if self.val = UInt32($4004) then Result := 'LIGHT4' else
if self.val = UInt32($4005) then Result := 'LIGHT5' else
if self.val = UInt32($4006) then Result := 'LIGHT6' else
if self.val = UInt32($4007) then Result := 'LIGHT7' else
if self.val = UInt32($8005) then Result := 'BLEND_COLOR' else
if self.val = UInt32($8005) then Result := 'BLEND_COLOR_EXT' else
if self.val = UInt32($8009) then Result := 'BLEND_EQUATION_EXT' else
if self.val = UInt32($8009) then Result := 'BLEND_EQUATION_RGB' else
if self.val = UInt32($800E) then Result := 'PACK_CMYK_HINT_EXT' else
if self.val = UInt32($800F) then Result := 'UNPACK_CMYK_HINT_EXT' else
if self.val = UInt32($8010) then Result := 'CONVOLUTION_1D_EXT' else
if self.val = UInt32($8011) then Result := 'CONVOLUTION_2D_EXT' else
if self.val = UInt32($8012) then Result := 'SEPARABLE_2D_EXT' else
if self.val = UInt32($801C) then Result := 'POST_CONVOLUTION_RED_SCALE_EXT' else
if self.val = UInt32($801D) then Result := 'POST_CONVOLUTION_GREEN_SCALE_EXT' else
if self.val = UInt32($801E) then Result := 'POST_CONVOLUTION_BLUE_SCALE_EXT' else
if self.val = UInt32($801F) then Result := 'POST_CONVOLUTION_ALPHA_SCALE_EXT' else
if self.val = UInt32($8020) then Result := 'POST_CONVOLUTION_RED_BIAS_EXT' else
if self.val = UInt32($8021) then Result := 'POST_CONVOLUTION_GREEN_BIAS_EXT' else
if self.val = UInt32($8022) then Result := 'POST_CONVOLUTION_BLUE_BIAS_EXT' else
if self.val = UInt32($8023) then Result := 'POST_CONVOLUTION_ALPHA_BIAS_EXT' else
if self.val = UInt32($8024) then Result := 'HISTOGRAM_EXT' else
if self.val = UInt32($802E) then Result := 'MINMAX_EXT' else
if self.val = UInt32($8037) then Result := 'POLYGON_OFFSET_FILL' else
if self.val = UInt32($8038) then Result := 'POLYGON_OFFSET_FACTOR' else
if self.val = UInt32($8039) then Result := 'POLYGON_OFFSET_BIAS_EXT' else
if self.val = UInt32($803A) then Result := 'RESCALE_NORMAL_EXT' else
if self.val = UInt32($8068) then Result := 'TEXTURE_BINDING_1D' else
if self.val = UInt32($8069) then Result := 'TEXTURE_BINDING_2D' else
if self.val = UInt32($806A) then Result := 'TEXTURE_3D_BINDING_EXT' else
if self.val = UInt32($806A) then Result := 'TEXTURE_BINDING_3D' else
if self.val = UInt32($806B) then Result := 'PACK_SKIP_IMAGES' else
if self.val = UInt32($806B) then Result := 'PACK_SKIP_IMAGES_EXT' else
if self.val = UInt32($806C) then Result := 'PACK_IMAGE_HEIGHT' else
if self.val = UInt32($806C) then Result := 'PACK_IMAGE_HEIGHT_EXT' else
if self.val = UInt32($806D) then Result := 'UNPACK_SKIP_IMAGES' else
if self.val = UInt32($806D) then Result := 'UNPACK_SKIP_IMAGES_EXT' else
if self.val = UInt32($806E) then Result := 'UNPACK_IMAGE_HEIGHT' else
if self.val = UInt32($806E) then Result := 'UNPACK_IMAGE_HEIGHT_EXT' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D_EXT' else
if self.val = UInt32($8073) then Result := 'MAX_3D_TEXTURE_SIZE' else
if self.val = UInt32($8073) then Result := 'MAX_3D_TEXTURE_SIZE_EXT' else
if self.val = UInt32($8074) then Result := 'VERTEX_ARRAY' else
if self.val = UInt32($8075) then Result := 'NORMAL_ARRAY' else
if self.val = UInt32($8076) then Result := 'COLOR_ARRAY' else
if self.val = UInt32($8077) then Result := 'INDEX_ARRAY' else
if self.val = UInt32($8078) then Result := 'TEXTURE_COORD_ARRAY' else
if self.val = UInt32($8079) then Result := 'EDGE_FLAG_ARRAY' else
if self.val = UInt32($807A) then Result := 'VERTEX_ARRAY_SIZE' else
if self.val = UInt32($807B) then Result := 'VERTEX_ARRAY_TYPE' else
if self.val = UInt32($807C) then Result := 'VERTEX_ARRAY_STRIDE' else
if self.val = UInt32($807D) then Result := 'VERTEX_ARRAY_COUNT_EXT' else
if self.val = UInt32($807E) then Result := 'NORMAL_ARRAY_TYPE' else
if self.val = UInt32($807F) then Result := 'NORMAL_ARRAY_STRIDE' else
if self.val = UInt32($8080) then Result := 'NORMAL_ARRAY_COUNT_EXT' else
if self.val = UInt32($8081) then Result := 'COLOR_ARRAY_SIZE' else
if self.val = UInt32($8082) then Result := 'COLOR_ARRAY_TYPE' else
if self.val = UInt32($8083) then Result := 'COLOR_ARRAY_STRIDE' else
if self.val = UInt32($8084) then Result := 'COLOR_ARRAY_COUNT_EXT' else
if self.val = UInt32($8085) then Result := 'INDEX_ARRAY_TYPE' else
if self.val = UInt32($8086) then Result := 'INDEX_ARRAY_STRIDE' else
if self.val = UInt32($8087) then Result := 'INDEX_ARRAY_COUNT_EXT' else
if self.val = UInt32($8088) then Result := 'TEXTURE_COORD_ARRAY_SIZE' else
if self.val = UInt32($8089) then Result := 'TEXTURE_COORD_ARRAY_TYPE' else
if self.val = UInt32($808A) then Result := 'TEXTURE_COORD_ARRAY_STRIDE' else
if self.val = UInt32($808B) then Result := 'TEXTURE_COORD_ARRAY_COUNT_EXT' else
if self.val = UInt32($808C) then Result := 'EDGE_FLAG_ARRAY_STRIDE' else
if self.val = UInt32($808D) then Result := 'EDGE_FLAG_ARRAY_COUNT_EXT' else
if self.val = UInt32($8094) then Result := 'INTERLACE_SGIX' else
if self.val = UInt32($8096) then Result := 'DETAIL_TEXTURE_2D_BINDING_SGIS' else
if self.val = UInt32($809D) then Result := 'MULTISAMPLE_SGIS' else
if self.val = UInt32($809E) then Result := 'SAMPLE_ALPHA_TO_MASK_SGIS' else
if self.val = UInt32($809F) then Result := 'SAMPLE_ALPHA_TO_ONE_SGIS' else
if self.val = UInt32($80A0) then Result := 'SAMPLE_MASK_SGIS' else
if self.val = UInt32($80A8) then Result := 'SAMPLE_BUFFERS' else
if self.val = UInt32($80A8) then Result := 'SAMPLE_BUFFERS_SGIS' else
if self.val = UInt32($80A9) then Result := 'SAMPLES' else
if self.val = UInt32($80A9) then Result := 'SAMPLES_SGIS' else
if self.val = UInt32($80AA) then Result := 'SAMPLE_COVERAGE_VALUE' else
if self.val = UInt32($80AA) then Result := 'SAMPLE_MASK_VALUE_SGIS' else
if self.val = UInt32($80AB) then Result := 'SAMPLE_COVERAGE_INVERT' else
if self.val = UInt32($80AB) then Result := 'SAMPLE_MASK_INVERT_SGIS' else
if self.val = UInt32($80AC) then Result := 'SAMPLE_PATTERN_SGIS' else
if self.val = UInt32($80B1) then Result := 'COLOR_MATRIX_SGI' else
if self.val = UInt32($80B2) then Result := 'COLOR_MATRIX_STACK_DEPTH_SGI' else
if self.val = UInt32($80B3) then Result := 'MAX_COLOR_MATRIX_STACK_DEPTH_SGI' else
if self.val = UInt32($80B4) then Result := 'POST_COLOR_MATRIX_RED_SCALE_SGI' else
if self.val = UInt32($80B5) then Result := 'POST_COLOR_MATRIX_GREEN_SCALE_SGI' else
if self.val = UInt32($80B6) then Result := 'POST_COLOR_MATRIX_BLUE_SCALE_SGI' else
if self.val = UInt32($80B7) then Result := 'POST_COLOR_MATRIX_ALPHA_SCALE_SGI' else
if self.val = UInt32($80B8) then Result := 'POST_COLOR_MATRIX_RED_BIAS_SGI' else
if self.val = UInt32($80B9) then Result := 'POST_COLOR_MATRIX_GREEN_BIAS_SGI' else
if self.val = UInt32($80BA) then Result := 'POST_COLOR_MATRIX_BLUE_BIAS_SGI' else
if self.val = UInt32($80BB) then Result := 'POST_COLOR_MATRIX_ALPHA_BIAS_SGI' else
if self.val = UInt32($80BC) then Result := 'TEXTURE_COLOR_TABLE_SGI' else
if self.val = UInt32($80C8) then Result := 'BLEND_DST_RGB' else
if self.val = UInt32($80C9) then Result := 'BLEND_SRC_RGB' else
if self.val = UInt32($80CA) then Result := 'BLEND_DST_ALPHA' else
if self.val = UInt32($80CB) then Result := 'BLEND_SRC_ALPHA' else
if self.val = UInt32($80D0) then Result := 'COLOR_TABLE_SGI' else
if self.val = UInt32($80D1) then Result := 'POST_CONVOLUTION_COLOR_TABLE_SGI' else
if self.val = UInt32($80D2) then Result := 'POST_COLOR_MATRIX_COLOR_TABLE_SGI' else
if self.val = UInt32($80E8) then Result := 'MAX_ELEMENTS_VERTICES' else
if self.val = UInt32($80E9) then Result := 'MAX_ELEMENTS_INDICES' else
if self.val = UInt32($8126) then Result := 'POINT_SIZE_MIN_SGIS' else
if self.val = UInt32($8127) then Result := 'POINT_SIZE_MAX_SGIS' else
if self.val = UInt32($8128) then Result := 'POINT_FADE_THRESHOLD_SIZE' else
if self.val = UInt32($8128) then Result := 'POINT_FADE_THRESHOLD_SIZE_SGIS' else
if self.val = UInt32($8129) then Result := 'DISTANCE_ATTENUATION_SGIS' else
if self.val = UInt32($812B) then Result := 'FOG_FUNC_POINTS_SGIS' else
if self.val = UInt32($812C) then Result := 'MAX_FOG_FUNC_POINTS_SGIS' else
if self.val = UInt32($8130) then Result := 'PACK_SKIP_VOLUMES_SGIS' else
if self.val = UInt32($8131) then Result := 'PACK_IMAGE_DEPTH_SGIS' else
if self.val = UInt32($8132) then Result := 'UNPACK_SKIP_VOLUMES_SGIS' else
if self.val = UInt32($8133) then Result := 'UNPACK_IMAGE_DEPTH_SGIS' else
if self.val = UInt32($8134) then Result := 'TEXTURE_4D_SGIS' else
if self.val = UInt32($8138) then Result := 'MAX_4D_TEXTURE_SIZE_SGIS' else
if self.val = UInt32($8139) then Result := 'PIXEL_TEX_GEN_SGIX' else
if self.val = UInt32($813E) then Result := 'PIXEL_TILE_BEST_ALIGNMENT_SGIX' else
if self.val = UInt32($813F) then Result := 'PIXEL_TILE_CACHE_INCREMENT_SGIX' else
if self.val = UInt32($8140) then Result := 'PIXEL_TILE_WIDTH_SGIX' else
if self.val = UInt32($8141) then Result := 'PIXEL_TILE_HEIGHT_SGIX' else
if self.val = UInt32($8142) then Result := 'PIXEL_TILE_GRID_WIDTH_SGIX' else
if self.val = UInt32($8143) then Result := 'PIXEL_TILE_GRID_HEIGHT_SGIX' else
if self.val = UInt32($8144) then Result := 'PIXEL_TILE_GRID_DEPTH_SGIX' else
if self.val = UInt32($8145) then Result := 'PIXEL_TILE_CACHE_SIZE_SGIX' else
if self.val = UInt32($8148) then Result := 'SPRITE_SGIX' else
if self.val = UInt32($8149) then Result := 'SPRITE_MODE_SGIX' else
if self.val = UInt32($814A) then Result := 'SPRITE_AXIS_SGIX' else
if self.val = UInt32($814B) then Result := 'SPRITE_TRANSLATION_SGIX' else
if self.val = UInt32($814F) then Result := 'TEXTURE_4D_BINDING_SGIS' else
if self.val = UInt32($8177) then Result := 'MAX_CLIPMAP_DEPTH_SGIX' else
if self.val = UInt32($8178) then Result := 'MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX' else
if self.val = UInt32($817B) then Result := 'POST_TEXTURE_FILTER_BIAS_RANGE_SGIX' else
if self.val = UInt32($817C) then Result := 'POST_TEXTURE_FILTER_SCALE_RANGE_SGIX' else
if self.val = UInt32($817D) then Result := 'REFERENCE_PLANE_SGIX' else
if self.val = UInt32($817E) then Result := 'REFERENCE_PLANE_EQUATION_SGIX' else
if self.val = UInt32($817F) then Result := 'IR_INSTRUMENT1_SGIX' else
if self.val = UInt32($8181) then Result := 'INSTRUMENT_MEASUREMENTS_SGIX' else
if self.val = UInt32($8183) then Result := 'CALLIGRAPHIC_FRAGMENT_SGIX' else
if self.val = UInt32($818B) then Result := 'FRAMEZOOM_SGIX' else
if self.val = UInt32($818C) then Result := 'FRAMEZOOM_FACTOR_SGIX' else
if self.val = UInt32($818D) then Result := 'MAX_FRAMEZOOM_FACTOR_SGIX' else
if self.val = UInt32($8192) then Result := 'GENERATE_MIPMAP_HINT_SGIS' else
if self.val = UInt32($8196) then Result := 'DEFORMATIONS_MASK_SGIX' else
if self.val = UInt32($8198) then Result := 'FOG_OFFSET_SGIX' else
if self.val = UInt32($8199) then Result := 'FOG_OFFSET_VALUE_SGIX' else
if self.val = UInt32($81F8) then Result := 'LIGHT_MODEL_COLOR_CONTROL' else
if self.val = UInt32($81FB) then Result := 'SHARED_TEXTURE_PALETTE_EXT' else
if self.val = UInt32($821B) then Result := 'MAJOR_VERSION' else
if self.val = UInt32($821C) then Result := 'MINOR_VERSION' else
if self.val = UInt32($821D) then Result := 'NUM_EXTENSIONS' else
if self.val = UInt32($821E) then Result := 'CONTEXT_FLAGS' else
if self.val = UInt32($825A) then Result := 'PROGRAM_PIPELINE_BINDING' else
if self.val = UInt32($825B) then Result := 'MAX_VIEWPORTS' else
if self.val = UInt32($825C) then Result := 'VIEWPORT_SUBPIXEL_BITS' else
if self.val = UInt32($825D) then Result := 'VIEWPORT_BOUNDS_RANGE' else
if self.val = UInt32($825E) then Result := 'LAYER_PROVOKING_VERTEX' else
if self.val = UInt32($825F) then Result := 'VIEWPORT_INDEX_PROVOKING_VERTEX' else
if self.val = UInt32($8263) then Result := 'MAX_COMPUTE_UNIFORM_COMPONENTS' else
if self.val = UInt32($8264) then Result := 'MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS' else
if self.val = UInt32($8265) then Result := 'MAX_COMPUTE_ATOMIC_COUNTERS' else
if self.val = UInt32($8266) then Result := 'MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS' else
if self.val = UInt32($826C) then Result := 'MAX_DEBUG_GROUP_STACK_DEPTH' else
if self.val = UInt32($826D) then Result := 'DEBUG_GROUP_STACK_DEPTH' else
if self.val = UInt32($826E) then Result := 'MAX_UNIFORM_LOCATIONS' else
if self.val = UInt32($82D6) then Result := 'VERTEX_BINDING_DIVISOR' else
if self.val = UInt32($82D7) then Result := 'VERTEX_BINDING_OFFSET' else
if self.val = UInt32($82D8) then Result := 'VERTEX_BINDING_STRIDE' else
if self.val = UInt32($82D9) then Result := 'MAX_VERTEX_ATTRIB_RELATIVE_OFFSET' else
if self.val = UInt32($82DA) then Result := 'MAX_VERTEX_ATTRIB_BINDINGS' else
if self.val = UInt32($82E8) then Result := 'MAX_LABEL_LENGTH' else
if self.val = UInt32($8316) then Result := 'CONVOLUTION_HINT_SGIX' else
if self.val = UInt32($8329) then Result := 'ASYNC_MARKER_SGIX' else
if self.val = UInt32($832B) then Result := 'PIXEL_TEX_GEN_MODE_SGIX' else
if self.val = UInt32($832C) then Result := 'ASYNC_HISTOGRAM_SGIX' else
if self.val = UInt32($832D) then Result := 'MAX_ASYNC_HISTOGRAM_SGIX' else
if self.val = UInt32($8353) then Result := 'PIXEL_TEXTURE_SGIS' else
if self.val = UInt32($835C) then Result := 'ASYNC_TEX_IMAGE_SGIX' else
if self.val = UInt32($835D) then Result := 'ASYNC_DRAW_PIXELS_SGIX' else
if self.val = UInt32($835E) then Result := 'ASYNC_READ_PIXELS_SGIX' else
if self.val = UInt32($835F) then Result := 'MAX_ASYNC_TEX_IMAGE_SGIX' else
if self.val = UInt32($8360) then Result := 'MAX_ASYNC_DRAW_PIXELS_SGIX' else
if self.val = UInt32($8361) then Result := 'MAX_ASYNC_READ_PIXELS_SGIX' else
if self.val = UInt32($83EE) then Result := 'VERTEX_PRECLIP_SGIX' else
if self.val = UInt32($83EF) then Result := 'VERTEX_PRECLIP_HINT_SGIX' else
if self.val = UInt32($8400) then Result := 'FRAGMENT_LIGHTING_SGIX' else
if self.val = UInt32($8401) then Result := 'FRAGMENT_COLOR_MATERIAL_SGIX' else
if self.val = UInt32($8402) then Result := 'FRAGMENT_COLOR_MATERIAL_FACE_SGIX' else
if self.val = UInt32($8403) then Result := 'FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX' else
if self.val = UInt32($8404) then Result := 'MAX_FRAGMENT_LIGHTS_SGIX' else
if self.val = UInt32($8405) then Result := 'MAX_ACTIVE_LIGHTS_SGIX' else
if self.val = UInt32($8407) then Result := 'LIGHT_ENV_MODE_SGIX' else
if self.val = UInt32($8408) then Result := 'FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX' else
if self.val = UInt32($8409) then Result := 'FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX' else
if self.val = UInt32($840A) then Result := 'FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX' else
if self.val = UInt32($840B) then Result := 'FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX' else
if self.val = UInt32($840C) then Result := 'FRAGMENT_LIGHT0_SGIX' else
if self.val = UInt32($842E) then Result := 'PACK_RESAMPLE_SGIX' else
if self.val = UInt32($842F) then Result := 'UNPACK_RESAMPLE_SGIX' else
if self.val = UInt32($846D) then Result := 'ALIASED_POINT_SIZE_RANGE' else
if self.val = UInt32($846E) then Result := 'ALIASED_LINE_WIDTH_RANGE' else
if self.val = UInt32($84E0) then Result := 'ACTIVE_TEXTURE' else
if self.val = UInt32($84E8) then Result := 'MAX_RENDERBUFFER_SIZE' else
if self.val = UInt32($84EF) then Result := 'TEXTURE_COMPRESSION_HINT' else
if self.val = UInt32($84F6) then Result := 'TEXTURE_BINDING_RECTANGLE' else
if self.val = UInt32($84F8) then Result := 'MAX_RECTANGLE_TEXTURE_SIZE' else
if self.val = UInt32($84FD) then Result := 'MAX_TEXTURE_LOD_BIAS' else
if self.val = UInt32($8514) then Result := 'TEXTURE_BINDING_CUBE_MAP' else
if self.val = UInt32($851C) then Result := 'MAX_CUBE_MAP_TEXTURE_SIZE' else
if self.val = UInt32($85A0) then Result := 'PACK_SUBSAMPLE_RATE_SGIX' else
if self.val = UInt32($85A1) then Result := 'UNPACK_SUBSAMPLE_RATE_SGIX' else
if self.val = UInt32($85B5) then Result := 'VERTEX_ARRAY_BINDING' else
if self.val = UInt32($8642) then Result := 'PROGRAM_POINT_SIZE' else
if self.val = UInt32($86A2) then Result := 'NUM_COMPRESSED_TEXTURE_FORMATS' else
if self.val = UInt32($86A3) then Result := 'COMPRESSED_TEXTURE_FORMATS' else
if self.val = UInt32($87FE) then Result := 'NUM_PROGRAM_BINARY_FORMATS' else
if self.val = UInt32($87FF) then Result := 'PROGRAM_BINARY_FORMATS' else
if self.val = UInt32($8800) then Result := 'STENCIL_BACK_FUNC' else
if self.val = UInt32($8801) then Result := 'STENCIL_BACK_FAIL' else
if self.val = UInt32($8802) then Result := 'STENCIL_BACK_PASS_DEPTH_FAIL' else
if self.val = UInt32($8803) then Result := 'STENCIL_BACK_PASS_DEPTH_PASS' else
if self.val = UInt32($8824) then Result := 'MAX_DRAW_BUFFERS' else
if self.val = UInt32($883D) then Result := 'BLEND_EQUATION_ALPHA' else
if self.val = UInt32($8869) then Result := 'MAX_VERTEX_ATTRIBS' else
if self.val = UInt32($8872) then Result := 'MAX_TEXTURE_IMAGE_UNITS' else
if self.val = UInt32($8894) then Result := 'ARRAY_BUFFER_BINDING' else
if self.val = UInt32($8895) then Result := 'ELEMENT_ARRAY_BUFFER_BINDING' else
if self.val = UInt32($88ED) then Result := 'PIXEL_PACK_BUFFER_BINDING' else
if self.val = UInt32($88EF) then Result := 'PIXEL_UNPACK_BUFFER_BINDING' else
if self.val = UInt32($88FC) then Result := 'MAX_DUAL_SOURCE_DRAW_BUFFERS' else
if self.val = UInt32($88FF) then Result := 'MAX_ARRAY_TEXTURE_LAYERS' else
if self.val = UInt32($8904) then Result := 'MIN_PROGRAM_TEXEL_OFFSET' else
if self.val = UInt32($8905) then Result := 'MAX_PROGRAM_TEXEL_OFFSET' else
if self.val = UInt32($8919) then Result := 'SAMPLER_BINDING' else
if self.val = UInt32($8A28) then Result := 'UNIFORM_BUFFER_BINDING' else
if self.val = UInt32($8A29) then Result := 'UNIFORM_BUFFER_START' else
if self.val = UInt32($8A2A) then Result := 'UNIFORM_BUFFER_SIZE' else
if self.val = UInt32($8A2B) then Result := 'MAX_VERTEX_UNIFORM_BLOCKS' else
if self.val = UInt32($8A2C) then Result := 'MAX_GEOMETRY_UNIFORM_BLOCKS' else
if self.val = UInt32($8A2D) then Result := 'MAX_FRAGMENT_UNIFORM_BLOCKS' else
if self.val = UInt32($8A2E) then Result := 'MAX_COMBINED_UNIFORM_BLOCKS' else
if self.val = UInt32($8A2F) then Result := 'MAX_UNIFORM_BUFFER_BINDINGS' else
if self.val = UInt32($8A30) then Result := 'MAX_UNIFORM_BLOCK_SIZE' else
if self.val = UInt32($8A31) then Result := 'MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS' else
if self.val = UInt32($8A32) then Result := 'MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS' else
if self.val = UInt32($8A33) then Result := 'MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS' else
if self.val = UInt32($8A34) then Result := 'UNIFORM_BUFFER_OFFSET_ALIGNMENT' else
if self.val = UInt32($8B49) then Result := 'MAX_FRAGMENT_UNIFORM_COMPONENTS' else
if self.val = UInt32($8B4A) then Result := 'MAX_VERTEX_UNIFORM_COMPONENTS' else
if self.val = UInt32($8B4B) then Result := 'MAX_VARYING_COMPONENTS' else
if self.val = UInt32($8B4B) then Result := 'MAX_VARYING_FLOATS' else
if self.val = UInt32($8B4C) then Result := 'MAX_VERTEX_TEXTURE_IMAGE_UNITS' else
if self.val = UInt32($8B4D) then Result := 'MAX_COMBINED_TEXTURE_IMAGE_UNITS' else
if self.val = UInt32($8B8B) then Result := 'FRAGMENT_SHADER_DERIVATIVE_HINT' else
if self.val = UInt32($8B8D) then Result := 'CURRENT_PROGRAM' else
if self.val = UInt32($8B9A) then Result := 'IMPLEMENTATION_COLOR_READ_TYPE' else
if self.val = UInt32($8B9B) then Result := 'IMPLEMENTATION_COLOR_READ_FORMAT' else
if self.val = UInt32($8C1C) then Result := 'TEXTURE_BINDING_1D_ARRAY' else
if self.val = UInt32($8C1D) then Result := 'TEXTURE_BINDING_2D_ARRAY' else
if self.val = UInt32($8C29) then Result := 'MAX_GEOMETRY_TEXTURE_IMAGE_UNITS' else
if self.val = UInt32($8C2B) then Result := 'MAX_TEXTURE_BUFFER_SIZE' else
if self.val = UInt32($8C2C) then Result := 'TEXTURE_BINDING_BUFFER' else
if self.val = UInt32($8C84) then Result := 'TRANSFORM_FEEDBACK_BUFFER_START' else
if self.val = UInt32($8C85) then Result := 'TRANSFORM_FEEDBACK_BUFFER_SIZE' else
if self.val = UInt32($8C8F) then Result := 'TRANSFORM_FEEDBACK_BUFFER_BINDING' else
if self.val = UInt32($8CA3) then Result := 'STENCIL_BACK_REF' else
if self.val = UInt32($8CA4) then Result := 'STENCIL_BACK_VALUE_MASK' else
if self.val = UInt32($8CA5) then Result := 'STENCIL_BACK_WRITEMASK' else
if self.val = UInt32($8CA6) then Result := 'DRAW_FRAMEBUFFER_BINDING' else
if self.val = UInt32($8CA7) then Result := 'RENDERBUFFER_BINDING' else
if self.val = UInt32($8CAA) then Result := 'READ_FRAMEBUFFER_BINDING' else
if self.val = UInt32($8D6B) then Result := 'MAX_ELEMENT_INDEX' else
if self.val = UInt32($8DDF) then Result := 'MAX_GEOMETRY_UNIFORM_COMPONENTS' else
if self.val = UInt32($8DF9) then Result := 'NUM_SHADER_BINARY_FORMATS' else
if self.val = UInt32($8DFA) then Result := 'SHADER_COMPILER' else
if self.val = UInt32($8DFB) then Result := 'MAX_VERTEX_UNIFORM_VECTORS' else
if self.val = UInt32($8DFC) then Result := 'MAX_VARYING_VECTORS' else
if self.val = UInt32($8DFD) then Result := 'MAX_FRAGMENT_UNIFORM_VECTORS' else
if self.val = UInt32($8E28) then Result := 'TIMESTAMP' else
if self.val = UInt32($8E4F) then Result := 'PROVOKING_VERTEX' else
if self.val = UInt32($8E59) then Result := 'MAX_SAMPLE_MASK_WORDS' else
if self.val = UInt32($8F9E) then Result := 'PRIMITIVE_RESTART_INDEX' else
if self.val = UInt32($90BC) then Result := 'MIN_MAP_BUFFER_ALIGNMENT' else
if self.val = UInt32($90D3) then Result := 'SHADER_STORAGE_BUFFER_BINDING' else
if self.val = UInt32($90D4) then Result := 'SHADER_STORAGE_BUFFER_START' else
if self.val = UInt32($90D5) then Result := 'SHADER_STORAGE_BUFFER_SIZE' else
if self.val = UInt32($90D6) then Result := 'MAX_VERTEX_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90D7) then Result := 'MAX_GEOMETRY_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90D8) then Result := 'MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90D9) then Result := 'MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90DA) then Result := 'MAX_FRAGMENT_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90DB) then Result := 'MAX_COMPUTE_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90DC) then Result := 'MAX_COMBINED_SHADER_STORAGE_BLOCKS' else
if self.val = UInt32($90DD) then Result := 'MAX_SHADER_STORAGE_BUFFER_BINDINGS' else
if self.val = UInt32($90DF) then Result := 'SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT' else
if self.val = UInt32($90EB) then Result := 'MAX_COMPUTE_WORK_GROUP_INVOCATIONS' else
if self.val = UInt32($90EF) then Result := 'DISPATCH_INDIRECT_BUFFER_BINDING' else
if self.val = UInt32($9104) then Result := 'TEXTURE_BINDING_2D_MULTISAMPLE' else
if self.val = UInt32($9105) then Result := 'TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910E) then Result := 'MAX_COLOR_TEXTURE_SAMPLES' else
if self.val = UInt32($910F) then Result := 'MAX_DEPTH_TEXTURE_SAMPLES' else
if self.val = UInt32($9110) then Result := 'MAX_INTEGER_SAMPLES' else
if self.val = UInt32($9111) then Result := 'MAX_SERVER_WAIT_TIMEOUT' else
if self.val = UInt32($9122) then Result := 'MAX_VERTEX_OUTPUT_COMPONENTS' else
if self.val = UInt32($9123) then Result := 'MAX_GEOMETRY_INPUT_COMPONENTS' else
if self.val = UInt32($9124) then Result := 'MAX_GEOMETRY_OUTPUT_COMPONENTS' else
if self.val = UInt32($9125) then Result := 'MAX_FRAGMENT_INPUT_COMPONENTS' else
if self.val = UInt32($919F) then Result := 'TEXTURE_BUFFER_OFFSET_ALIGNMENT' else
if self.val = UInt32($91BB) then Result := 'MAX_COMPUTE_UNIFORM_BLOCKS' else
if self.val = UInt32($91BC) then Result := 'MAX_COMPUTE_TEXTURE_IMAGE_UNITS' else
if self.val = UInt32($91BE) then Result := 'MAX_COMPUTE_WORK_GROUP_COUNT' else
if self.val = UInt32($91BF) then Result := 'MAX_COMPUTE_WORK_GROUP_SIZE' else
if self.val = UInt32($92D2) then Result := 'MAX_VERTEX_ATOMIC_COUNTERS' else
if self.val = UInt32($92D3) then Result := 'MAX_TESS_CONTROL_ATOMIC_COUNTERS' else
if self.val = UInt32($92D4) then Result := 'MAX_TESS_EVALUATION_ATOMIC_COUNTERS' else
if self.val = UInt32($92D5) then Result := 'MAX_GEOMETRY_ATOMIC_COUNTERS' else
if self.val = UInt32($92D6) then Result := 'MAX_FRAGMENT_ATOMIC_COUNTERS' else
if self.val = UInt32($92D7) then Result := 'MAX_COMBINED_ATOMIC_COUNTERS' else
if self.val = UInt32($9315) then Result := 'MAX_FRAMEBUFFER_WIDTH' else
if self.val = UInt32($9316) then Result := 'MAX_FRAMEBUFFER_HEIGHT' else
if self.val = UInt32($9317) then Result := 'MAX_FRAMEBUFFER_LAYERS' else
if self.val = UInt32($9318) then Result := 'MAX_FRAMEBUFFER_SAMPLES' else
if self.val = UInt32($9596) then Result := 'NUM_DEVICE_UUIDS_EXT' else
if self.val = UInt32($9597) then Result := 'DEVICE_UUID_EXT' else
if self.val = UInt32($9598) then Result := 'DRIVER_UUID_EXT' else
if self.val = UInt32($9599) then Result := 'DEVICE_LUID_EXT' else
if self.val = UInt32($959A) then Result := 'DEVICE_NODE_MASK_EXT' else
Result := self.val.ToString;
end;
end;
GetPointervPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FEEDBACK_BUFFER_POINTER := new GetPointervPName($0DF0);
private static _SELECTION_BUFFER_POINTER := new GetPointervPName($0DF3);
private static _VERTEX_ARRAY_POINTER := new GetPointervPName($808E);
private static _VERTEX_ARRAY_POINTER_EXT := new GetPointervPName($808E);
private static _NORMAL_ARRAY_POINTER := new GetPointervPName($808F);
private static _NORMAL_ARRAY_POINTER_EXT := new GetPointervPName($808F);
private static _COLOR_ARRAY_POINTER := new GetPointervPName($8090);
private static _COLOR_ARRAY_POINTER_EXT := new GetPointervPName($8090);
private static _INDEX_ARRAY_POINTER := new GetPointervPName($8091);
private static _INDEX_ARRAY_POINTER_EXT := new GetPointervPName($8091);
private static _TEXTURE_COORD_ARRAY_POINTER := new GetPointervPName($8092);
private static _TEXTURE_COORD_ARRAY_POINTER_EXT := new GetPointervPName($8092);
private static _EDGE_FLAG_ARRAY_POINTER := new GetPointervPName($8093);
private static _EDGE_FLAG_ARRAY_POINTER_EXT := new GetPointervPName($8093);
private static _INSTRUMENT_BUFFER_POINTER_SGIX := new GetPointervPName($8180);
private static _DEBUG_CALLBACK_FUNCTION := new GetPointervPName($8244);
private static _DEBUG_CALLBACK_USER_PARAM := new GetPointervPName($8245);
public static property FEEDBACK_BUFFER_POINTER: GetPointervPName read _FEEDBACK_BUFFER_POINTER;
public static property SELECTION_BUFFER_POINTER: GetPointervPName read _SELECTION_BUFFER_POINTER;
public static property VERTEX_ARRAY_POINTER: GetPointervPName read _VERTEX_ARRAY_POINTER;
public static property VERTEX_ARRAY_POINTER_EXT: GetPointervPName read _VERTEX_ARRAY_POINTER_EXT;
public static property NORMAL_ARRAY_POINTER: GetPointervPName read _NORMAL_ARRAY_POINTER;
public static property NORMAL_ARRAY_POINTER_EXT: GetPointervPName read _NORMAL_ARRAY_POINTER_EXT;
public static property COLOR_ARRAY_POINTER: GetPointervPName read _COLOR_ARRAY_POINTER;
public static property COLOR_ARRAY_POINTER_EXT: GetPointervPName read _COLOR_ARRAY_POINTER_EXT;
public static property INDEX_ARRAY_POINTER: GetPointervPName read _INDEX_ARRAY_POINTER;
public static property INDEX_ARRAY_POINTER_EXT: GetPointervPName read _INDEX_ARRAY_POINTER_EXT;
public static property TEXTURE_COORD_ARRAY_POINTER: GetPointervPName read _TEXTURE_COORD_ARRAY_POINTER;
public static property TEXTURE_COORD_ARRAY_POINTER_EXT: GetPointervPName read _TEXTURE_COORD_ARRAY_POINTER_EXT;
public static property EDGE_FLAG_ARRAY_POINTER: GetPointervPName read _EDGE_FLAG_ARRAY_POINTER;
public static property EDGE_FLAG_ARRAY_POINTER_EXT: GetPointervPName read _EDGE_FLAG_ARRAY_POINTER_EXT;
public static property INSTRUMENT_BUFFER_POINTER_SGIX: GetPointervPName read _INSTRUMENT_BUFFER_POINTER_SGIX;
public static property DEBUG_CALLBACK_FUNCTION: GetPointervPName read _DEBUG_CALLBACK_FUNCTION;
public static property DEBUG_CALLBACK_USER_PARAM: GetPointervPName read _DEBUG_CALLBACK_USER_PARAM;
public function ToString: string; override;
begin
if self.val = UInt32($0DF0) then Result := 'FEEDBACK_BUFFER_POINTER' else
if self.val = UInt32($0DF3) then Result := 'SELECTION_BUFFER_POINTER' else
if self.val = UInt32($808E) then Result := 'VERTEX_ARRAY_POINTER' else
if self.val = UInt32($808E) then Result := 'VERTEX_ARRAY_POINTER_EXT' else
if self.val = UInt32($808F) then Result := 'NORMAL_ARRAY_POINTER' else
if self.val = UInt32($808F) then Result := 'NORMAL_ARRAY_POINTER_EXT' else
if self.val = UInt32($8090) then Result := 'COLOR_ARRAY_POINTER' else
if self.val = UInt32($8090) then Result := 'COLOR_ARRAY_POINTER_EXT' else
if self.val = UInt32($8091) then Result := 'INDEX_ARRAY_POINTER' else
if self.val = UInt32($8091) then Result := 'INDEX_ARRAY_POINTER_EXT' else
if self.val = UInt32($8092) then Result := 'TEXTURE_COORD_ARRAY_POINTER' else
if self.val = UInt32($8092) then Result := 'TEXTURE_COORD_ARRAY_POINTER_EXT' else
if self.val = UInt32($8093) then Result := 'EDGE_FLAG_ARRAY_POINTER' else
if self.val = UInt32($8093) then Result := 'EDGE_FLAG_ARRAY_POINTER_EXT' else
if self.val = UInt32($8180) then Result := 'INSTRUMENT_BUFFER_POINTER_SGIX' else
if self.val = UInt32($8244) then Result := 'DEBUG_CALLBACK_FUNCTION' else
if self.val = UInt32($8245) then Result := 'DEBUG_CALLBACK_USER_PARAM' else
Result := self.val.ToString;
end;
end;
GetTextureParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_WIDTH := new GetTextureParameter($1000);
private static _TEXTURE_HEIGHT := new GetTextureParameter($1001);
private static _TEXTURE_COMPONENTS := new GetTextureParameter($1003);
private static _TEXTURE_INTERNAL_FORMAT := new GetTextureParameter($1003);
private static _TEXTURE_BORDER_COLOR := new GetTextureParameter($1004);
private static _TEXTURE_BORDER_COLOR_NV := new GetTextureParameter($1004);
private static _TEXTURE_BORDER := new GetTextureParameter($1005);
private static _TEXTURE_MAG_FILTER := new GetTextureParameter($2800);
private static _TEXTURE_MIN_FILTER := new GetTextureParameter($2801);
private static _TEXTURE_WRAP_S := new GetTextureParameter($2802);
private static _TEXTURE_WRAP_T := new GetTextureParameter($2803);
private static _TEXTURE_RED_SIZE := new GetTextureParameter($805C);
private static _TEXTURE_GREEN_SIZE := new GetTextureParameter($805D);
private static _TEXTURE_BLUE_SIZE := new GetTextureParameter($805E);
private static _TEXTURE_ALPHA_SIZE := new GetTextureParameter($805F);
private static _TEXTURE_LUMINANCE_SIZE := new GetTextureParameter($8060);
private static _TEXTURE_INTENSITY_SIZE := new GetTextureParameter($8061);
private static _TEXTURE_PRIORITY := new GetTextureParameter($8066);
private static _TEXTURE_RESIDENT := new GetTextureParameter($8067);
private static _TEXTURE_DEPTH_EXT := new GetTextureParameter($8071);
private static _TEXTURE_WRAP_R_EXT := new GetTextureParameter($8072);
private static _DETAIL_TEXTURE_LEVEL_SGIS := new GetTextureParameter($809A);
private static _DETAIL_TEXTURE_MODE_SGIS := new GetTextureParameter($809B);
private static _DETAIL_TEXTURE_FUNC_POINTS_SGIS := new GetTextureParameter($809C);
private static _SHARPEN_TEXTURE_FUNC_POINTS_SGIS := new GetTextureParameter($80B0);
private static _SHADOW_AMBIENT_SGIX := new GetTextureParameter($80BF);
private static _DUAL_TEXTURE_SELECT_SGIS := new GetTextureParameter($8124);
private static _QUAD_TEXTURE_SELECT_SGIS := new GetTextureParameter($8125);
private static _TEXTURE_4DSIZE_SGIS := new GetTextureParameter($8136);
private static _TEXTURE_WRAP_Q_SGIS := new GetTextureParameter($8137);
private static _TEXTURE_MIN_LOD_SGIS := new GetTextureParameter($813A);
private static _TEXTURE_MAX_LOD_SGIS := new GetTextureParameter($813B);
private static _TEXTURE_BASE_LEVEL_SGIS := new GetTextureParameter($813C);
private static _TEXTURE_MAX_LEVEL_SGIS := new GetTextureParameter($813D);
private static _TEXTURE_FILTER4_SIZE_SGIS := new GetTextureParameter($8147);
private static _TEXTURE_CLIPMAP_CENTER_SGIX := new GetTextureParameter($8171);
private static _TEXTURE_CLIPMAP_FRAME_SGIX := new GetTextureParameter($8172);
private static _TEXTURE_CLIPMAP_OFFSET_SGIX := new GetTextureParameter($8173);
private static _TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX := new GetTextureParameter($8174);
private static _TEXTURE_CLIPMAP_LOD_OFFSET_SGIX := new GetTextureParameter($8175);
private static _TEXTURE_CLIPMAP_DEPTH_SGIX := new GetTextureParameter($8176);
private static _POST_TEXTURE_FILTER_BIAS_SGIX := new GetTextureParameter($8179);
private static _POST_TEXTURE_FILTER_SCALE_SGIX := new GetTextureParameter($817A);
private static _TEXTURE_LOD_BIAS_S_SGIX := new GetTextureParameter($818E);
private static _TEXTURE_LOD_BIAS_T_SGIX := new GetTextureParameter($818F);
private static _TEXTURE_LOD_BIAS_R_SGIX := new GetTextureParameter($8190);
private static _GENERATE_MIPMAP_SGIS := new GetTextureParameter($8191);
private static _TEXTURE_COMPARE_SGIX := new GetTextureParameter($819A);
private static _TEXTURE_COMPARE_OPERATOR_SGIX := new GetTextureParameter($819B);
private static _TEXTURE_LEQUAL_R_SGIX := new GetTextureParameter($819C);
private static _TEXTURE_GEQUAL_R_SGIX := new GetTextureParameter($819D);
private static _TEXTURE_MAX_CLAMP_S_SGIX := new GetTextureParameter($8369);
private static _TEXTURE_MAX_CLAMP_T_SGIX := new GetTextureParameter($836A);
private static _TEXTURE_MAX_CLAMP_R_SGIX := new GetTextureParameter($836B);
private static _TEXTURE_UNNORMALIZED_COORDINATES_ARM := new GetTextureParameter($8F6A);
public static property TEXTURE_WIDTH: GetTextureParameter read _TEXTURE_WIDTH;
public static property TEXTURE_HEIGHT: GetTextureParameter read _TEXTURE_HEIGHT;
public static property TEXTURE_COMPONENTS: GetTextureParameter read _TEXTURE_COMPONENTS;
public static property TEXTURE_INTERNAL_FORMAT: GetTextureParameter read _TEXTURE_INTERNAL_FORMAT;
public static property TEXTURE_BORDER_COLOR: GetTextureParameter read _TEXTURE_BORDER_COLOR;
public static property TEXTURE_BORDER_COLOR_NV: GetTextureParameter read _TEXTURE_BORDER_COLOR_NV;
public static property TEXTURE_BORDER: GetTextureParameter read _TEXTURE_BORDER;
public static property TEXTURE_MAG_FILTER: GetTextureParameter read _TEXTURE_MAG_FILTER;
public static property TEXTURE_MIN_FILTER: GetTextureParameter read _TEXTURE_MIN_FILTER;
public static property TEXTURE_WRAP_S: GetTextureParameter read _TEXTURE_WRAP_S;
public static property TEXTURE_WRAP_T: GetTextureParameter read _TEXTURE_WRAP_T;
public static property TEXTURE_RED_SIZE: GetTextureParameter read _TEXTURE_RED_SIZE;
public static property TEXTURE_GREEN_SIZE: GetTextureParameter read _TEXTURE_GREEN_SIZE;
public static property TEXTURE_BLUE_SIZE: GetTextureParameter read _TEXTURE_BLUE_SIZE;
public static property TEXTURE_ALPHA_SIZE: GetTextureParameter read _TEXTURE_ALPHA_SIZE;
public static property TEXTURE_LUMINANCE_SIZE: GetTextureParameter read _TEXTURE_LUMINANCE_SIZE;
public static property TEXTURE_INTENSITY_SIZE: GetTextureParameter read _TEXTURE_INTENSITY_SIZE;
public static property TEXTURE_PRIORITY: GetTextureParameter read _TEXTURE_PRIORITY;
public static property TEXTURE_RESIDENT: GetTextureParameter read _TEXTURE_RESIDENT;
public static property TEXTURE_DEPTH_EXT: GetTextureParameter read _TEXTURE_DEPTH_EXT;
public static property TEXTURE_WRAP_R_EXT: GetTextureParameter read _TEXTURE_WRAP_R_EXT;
public static property DETAIL_TEXTURE_LEVEL_SGIS: GetTextureParameter read _DETAIL_TEXTURE_LEVEL_SGIS;
public static property DETAIL_TEXTURE_MODE_SGIS: GetTextureParameter read _DETAIL_TEXTURE_MODE_SGIS;
public static property DETAIL_TEXTURE_FUNC_POINTS_SGIS: GetTextureParameter read _DETAIL_TEXTURE_FUNC_POINTS_SGIS;
public static property SHARPEN_TEXTURE_FUNC_POINTS_SGIS: GetTextureParameter read _SHARPEN_TEXTURE_FUNC_POINTS_SGIS;
public static property SHADOW_AMBIENT_SGIX: GetTextureParameter read _SHADOW_AMBIENT_SGIX;
public static property DUAL_TEXTURE_SELECT_SGIS: GetTextureParameter read _DUAL_TEXTURE_SELECT_SGIS;
public static property QUAD_TEXTURE_SELECT_SGIS: GetTextureParameter read _QUAD_TEXTURE_SELECT_SGIS;
public static property TEXTURE_4DSIZE_SGIS: GetTextureParameter read _TEXTURE_4DSIZE_SGIS;
public static property TEXTURE_WRAP_Q_SGIS: GetTextureParameter read _TEXTURE_WRAP_Q_SGIS;
public static property TEXTURE_MIN_LOD_SGIS: GetTextureParameter read _TEXTURE_MIN_LOD_SGIS;
public static property TEXTURE_MAX_LOD_SGIS: GetTextureParameter read _TEXTURE_MAX_LOD_SGIS;
public static property TEXTURE_BASE_LEVEL_SGIS: GetTextureParameter read _TEXTURE_BASE_LEVEL_SGIS;
public static property TEXTURE_MAX_LEVEL_SGIS: GetTextureParameter read _TEXTURE_MAX_LEVEL_SGIS;
public static property TEXTURE_FILTER4_SIZE_SGIS: GetTextureParameter read _TEXTURE_FILTER4_SIZE_SGIS;
public static property TEXTURE_CLIPMAP_CENTER_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_CENTER_SGIX;
public static property TEXTURE_CLIPMAP_FRAME_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_FRAME_SGIX;
public static property TEXTURE_CLIPMAP_OFFSET_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_OFFSET_SGIX;
public static property TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX;
public static property TEXTURE_CLIPMAP_LOD_OFFSET_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_LOD_OFFSET_SGIX;
public static property TEXTURE_CLIPMAP_DEPTH_SGIX: GetTextureParameter read _TEXTURE_CLIPMAP_DEPTH_SGIX;
public static property POST_TEXTURE_FILTER_BIAS_SGIX: GetTextureParameter read _POST_TEXTURE_FILTER_BIAS_SGIX;
public static property POST_TEXTURE_FILTER_SCALE_SGIX: GetTextureParameter read _POST_TEXTURE_FILTER_SCALE_SGIX;
public static property TEXTURE_LOD_BIAS_S_SGIX: GetTextureParameter read _TEXTURE_LOD_BIAS_S_SGIX;
public static property TEXTURE_LOD_BIAS_T_SGIX: GetTextureParameter read _TEXTURE_LOD_BIAS_T_SGIX;
public static property TEXTURE_LOD_BIAS_R_SGIX: GetTextureParameter read _TEXTURE_LOD_BIAS_R_SGIX;
public static property GENERATE_MIPMAP_SGIS: GetTextureParameter read _GENERATE_MIPMAP_SGIS;
public static property TEXTURE_COMPARE_SGIX: GetTextureParameter read _TEXTURE_COMPARE_SGIX;
public static property TEXTURE_COMPARE_OPERATOR_SGIX: GetTextureParameter read _TEXTURE_COMPARE_OPERATOR_SGIX;
public static property TEXTURE_LEQUAL_R_SGIX: GetTextureParameter read _TEXTURE_LEQUAL_R_SGIX;
public static property TEXTURE_GEQUAL_R_SGIX: GetTextureParameter read _TEXTURE_GEQUAL_R_SGIX;
public static property TEXTURE_MAX_CLAMP_S_SGIX: GetTextureParameter read _TEXTURE_MAX_CLAMP_S_SGIX;
public static property TEXTURE_MAX_CLAMP_T_SGIX: GetTextureParameter read _TEXTURE_MAX_CLAMP_T_SGIX;
public static property TEXTURE_MAX_CLAMP_R_SGIX: GetTextureParameter read _TEXTURE_MAX_CLAMP_R_SGIX;
public static property TEXTURE_UNNORMALIZED_COORDINATES_ARM: GetTextureParameter read _TEXTURE_UNNORMALIZED_COORDINATES_ARM;
public function ToString: string; override;
begin
if self.val = UInt32($1000) then Result := 'TEXTURE_WIDTH' else
if self.val = UInt32($1001) then Result := 'TEXTURE_HEIGHT' else
if self.val = UInt32($1003) then Result := 'TEXTURE_COMPONENTS' else
if self.val = UInt32($1003) then Result := 'TEXTURE_INTERNAL_FORMAT' else
if self.val = UInt32($1004) then Result := 'TEXTURE_BORDER_COLOR' else
if self.val = UInt32($1004) then Result := 'TEXTURE_BORDER_COLOR_NV' else
if self.val = UInt32($1005) then Result := 'TEXTURE_BORDER' else
if self.val = UInt32($2800) then Result := 'TEXTURE_MAG_FILTER' else
if self.val = UInt32($2801) then Result := 'TEXTURE_MIN_FILTER' else
if self.val = UInt32($2802) then Result := 'TEXTURE_WRAP_S' else
if self.val = UInt32($2803) then Result := 'TEXTURE_WRAP_T' else
if self.val = UInt32($805C) then Result := 'TEXTURE_RED_SIZE' else
if self.val = UInt32($805D) then Result := 'TEXTURE_GREEN_SIZE' else
if self.val = UInt32($805E) then Result := 'TEXTURE_BLUE_SIZE' else
if self.val = UInt32($805F) then Result := 'TEXTURE_ALPHA_SIZE' else
if self.val = UInt32($8060) then Result := 'TEXTURE_LUMINANCE_SIZE' else
if self.val = UInt32($8061) then Result := 'TEXTURE_INTENSITY_SIZE' else
if self.val = UInt32($8066) then Result := 'TEXTURE_PRIORITY' else
if self.val = UInt32($8067) then Result := 'TEXTURE_RESIDENT' else
if self.val = UInt32($8071) then Result := 'TEXTURE_DEPTH_EXT' else
if self.val = UInt32($8072) then Result := 'TEXTURE_WRAP_R_EXT' else
if self.val = UInt32($809A) then Result := 'DETAIL_TEXTURE_LEVEL_SGIS' else
if self.val = UInt32($809B) then Result := 'DETAIL_TEXTURE_MODE_SGIS' else
if self.val = UInt32($809C) then Result := 'DETAIL_TEXTURE_FUNC_POINTS_SGIS' else
if self.val = UInt32($80B0) then Result := 'SHARPEN_TEXTURE_FUNC_POINTS_SGIS' else
if self.val = UInt32($80BF) then Result := 'SHADOW_AMBIENT_SGIX' else
if self.val = UInt32($8124) then Result := 'DUAL_TEXTURE_SELECT_SGIS' else
if self.val = UInt32($8125) then Result := 'QUAD_TEXTURE_SELECT_SGIS' else
if self.val = UInt32($8136) then Result := 'TEXTURE_4DSIZE_SGIS' else
if self.val = UInt32($8137) then Result := 'TEXTURE_WRAP_Q_SGIS' else
if self.val = UInt32($813A) then Result := 'TEXTURE_MIN_LOD_SGIS' else
if self.val = UInt32($813B) then Result := 'TEXTURE_MAX_LOD_SGIS' else
if self.val = UInt32($813C) then Result := 'TEXTURE_BASE_LEVEL_SGIS' else
if self.val = UInt32($813D) then Result := 'TEXTURE_MAX_LEVEL_SGIS' else
if self.val = UInt32($8147) then Result := 'TEXTURE_FILTER4_SIZE_SGIS' else
if self.val = UInt32($8171) then Result := 'TEXTURE_CLIPMAP_CENTER_SGIX' else
if self.val = UInt32($8172) then Result := 'TEXTURE_CLIPMAP_FRAME_SGIX' else
if self.val = UInt32($8173) then Result := 'TEXTURE_CLIPMAP_OFFSET_SGIX' else
if self.val = UInt32($8174) then Result := 'TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX' else
if self.val = UInt32($8175) then Result := 'TEXTURE_CLIPMAP_LOD_OFFSET_SGIX' else
if self.val = UInt32($8176) then Result := 'TEXTURE_CLIPMAP_DEPTH_SGIX' else
if self.val = UInt32($8179) then Result := 'POST_TEXTURE_FILTER_BIAS_SGIX' else
if self.val = UInt32($817A) then Result := 'POST_TEXTURE_FILTER_SCALE_SGIX' else
if self.val = UInt32($818E) then Result := 'TEXTURE_LOD_BIAS_S_SGIX' else
if self.val = UInt32($818F) then Result := 'TEXTURE_LOD_BIAS_T_SGIX' else
if self.val = UInt32($8190) then Result := 'TEXTURE_LOD_BIAS_R_SGIX' else
if self.val = UInt32($8191) then Result := 'GENERATE_MIPMAP_SGIS' else
if self.val = UInt32($819A) then Result := 'TEXTURE_COMPARE_SGIX' else
if self.val = UInt32($819B) then Result := 'TEXTURE_COMPARE_OPERATOR_SGIX' else
if self.val = UInt32($819C) then Result := 'TEXTURE_LEQUAL_R_SGIX' else
if self.val = UInt32($819D) then Result := 'TEXTURE_GEQUAL_R_SGIX' else
if self.val = UInt32($8369) then Result := 'TEXTURE_MAX_CLAMP_S_SGIX' else
if self.val = UInt32($836A) then Result := 'TEXTURE_MAX_CLAMP_T_SGIX' else
if self.val = UInt32($836B) then Result := 'TEXTURE_MAX_CLAMP_R_SGIX' else
if self.val = UInt32($8F6A) then Result := 'TEXTURE_UNNORMALIZED_COORDINATES_ARM' else
Result := self.val.ToString;
end;
end;
GlslTypeToken = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INT := new GlslTypeToken($1404);
private static _UNSIGNED_INT := new GlslTypeToken($1405);
private static _FLOAT := new GlslTypeToken($1406);
private static _DOUBLE := new GlslTypeToken($140A);
private static _FLOAT_VEC2 := new GlslTypeToken($8B50);
private static _FLOAT_VEC3 := new GlslTypeToken($8B51);
private static _FLOAT_VEC4 := new GlslTypeToken($8B52);
private static _INT_VEC2 := new GlslTypeToken($8B53);
private static _INT_VEC3 := new GlslTypeToken($8B54);
private static _INT_VEC4 := new GlslTypeToken($8B55);
private static _BOOL := new GlslTypeToken($8B56);
private static _BOOL_VEC2 := new GlslTypeToken($8B57);
private static _BOOL_VEC3 := new GlslTypeToken($8B58);
private static _BOOL_VEC4 := new GlslTypeToken($8B59);
private static _FLOAT_MAT2 := new GlslTypeToken($8B5A);
private static _FLOAT_MAT3 := new GlslTypeToken($8B5B);
private static _FLOAT_MAT4 := new GlslTypeToken($8B5C);
private static _SAMPLER_1D := new GlslTypeToken($8B5D);
private static _SAMPLER_2D := new GlslTypeToken($8B5E);
private static _SAMPLER_3D := new GlslTypeToken($8B5F);
private static _SAMPLER_CUBE := new GlslTypeToken($8B60);
private static _SAMPLER_1D_SHADOW := new GlslTypeToken($8B61);
private static _SAMPLER_2D_SHADOW := new GlslTypeToken($8B62);
private static _SAMPLER_2D_RECT := new GlslTypeToken($8B63);
private static _SAMPLER_2D_RECT_SHADOW := new GlslTypeToken($8B64);
private static _FLOAT_MAT2x3 := new GlslTypeToken($8B65);
private static _FLOAT_MAT2x4 := new GlslTypeToken($8B66);
private static _FLOAT_MAT3x2 := new GlslTypeToken($8B67);
private static _FLOAT_MAT3x4 := new GlslTypeToken($8B68);
private static _FLOAT_MAT4x2 := new GlslTypeToken($8B69);
private static _FLOAT_MAT4x3 := new GlslTypeToken($8B6A);
private static _SAMPLER_1D_ARRAY := new GlslTypeToken($8DC0);
private static _SAMPLER_2D_ARRAY := new GlslTypeToken($8DC1);
private static _SAMPLER_BUFFER := new GlslTypeToken($8DC2);
private static _SAMPLER_1D_ARRAY_SHADOW := new GlslTypeToken($8DC3);
private static _SAMPLER_2D_ARRAY_SHADOW := new GlslTypeToken($8DC4);
private static _SAMPLER_CUBE_SHADOW := new GlslTypeToken($8DC5);
private static _UNSIGNED_INT_VEC2 := new GlslTypeToken($8DC6);
private static _UNSIGNED_INT_VEC3 := new GlslTypeToken($8DC7);
private static _UNSIGNED_INT_VEC4 := new GlslTypeToken($8DC8);
private static _INT_SAMPLER_1D := new GlslTypeToken($8DC9);
private static _INT_SAMPLER_2D := new GlslTypeToken($8DCA);
private static _INT_SAMPLER_3D := new GlslTypeToken($8DCB);
private static _INT_SAMPLER_CUBE := new GlslTypeToken($8DCC);
private static _INT_SAMPLER_2D_RECT := new GlslTypeToken($8DCD);
private static _INT_SAMPLER_1D_ARRAY := new GlslTypeToken($8DCE);
private static _INT_SAMPLER_2D_ARRAY := new GlslTypeToken($8DCF);
private static _INT_SAMPLER_BUFFER := new GlslTypeToken($8DD0);
private static _UNSIGNED_INT_SAMPLER_1D := new GlslTypeToken($8DD1);
private static _UNSIGNED_INT_SAMPLER_2D := new GlslTypeToken($8DD2);
private static _UNSIGNED_INT_SAMPLER_3D := new GlslTypeToken($8DD3);
private static _UNSIGNED_INT_SAMPLER_CUBE := new GlslTypeToken($8DD4);
private static _UNSIGNED_INT_SAMPLER_2D_RECT := new GlslTypeToken($8DD5);
private static _UNSIGNED_INT_SAMPLER_1D_ARRAY := new GlslTypeToken($8DD6);
private static _UNSIGNED_INT_SAMPLER_2D_ARRAY := new GlslTypeToken($8DD7);
private static _UNSIGNED_INT_SAMPLER_BUFFER := new GlslTypeToken($8DD8);
private static _DOUBLE_MAT2 := new GlslTypeToken($8F46);
private static _DOUBLE_MAT3 := new GlslTypeToken($8F47);
private static _DOUBLE_MAT4 := new GlslTypeToken($8F48);
private static _DOUBLE_VEC2 := new GlslTypeToken($8FFC);
private static _DOUBLE_VEC3 := new GlslTypeToken($8FFD);
private static _DOUBLE_VEC4 := new GlslTypeToken($8FFE);
private static _SAMPLER_CUBE_MAP_ARRAY := new GlslTypeToken($900C);
private static _SAMPLER_CUBE_MAP_ARRAY_SHADOW := new GlslTypeToken($900D);
private static _INT_SAMPLER_CUBE_MAP_ARRAY := new GlslTypeToken($900E);
private static _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY := new GlslTypeToken($900F);
private static _IMAGE_1D := new GlslTypeToken($904C);
private static _IMAGE_2D := new GlslTypeToken($904D);
private static _IMAGE_3D := new GlslTypeToken($904E);
private static _IMAGE_2D_RECT := new GlslTypeToken($904F);
private static _IMAGE_CUBE := new GlslTypeToken($9050);
private static _IMAGE_BUFFER := new GlslTypeToken($9051);
private static _IMAGE_1D_ARRAY := new GlslTypeToken($9052);
private static _IMAGE_2D_ARRAY := new GlslTypeToken($9053);
private static _IMAGE_CUBE_MAP_ARRAY := new GlslTypeToken($9054);
private static _IMAGE_2D_MULTISAMPLE := new GlslTypeToken($9055);
private static _IMAGE_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($9056);
private static _INT_IMAGE_1D := new GlslTypeToken($9057);
private static _INT_IMAGE_2D := new GlslTypeToken($9058);
private static _INT_IMAGE_3D := new GlslTypeToken($9059);
private static _INT_IMAGE_2D_RECT := new GlslTypeToken($905A);
private static _INT_IMAGE_CUBE := new GlslTypeToken($905B);
private static _INT_IMAGE_BUFFER := new GlslTypeToken($905C);
private static _INT_IMAGE_1D_ARRAY := new GlslTypeToken($905D);
private static _INT_IMAGE_2D_ARRAY := new GlslTypeToken($905E);
private static _INT_IMAGE_CUBE_MAP_ARRAY := new GlslTypeToken($905F);
private static _INT_IMAGE_2D_MULTISAMPLE := new GlslTypeToken($9060);
private static _INT_IMAGE_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($9061);
private static _UNSIGNED_INT_IMAGE_1D := new GlslTypeToken($9062);
private static _UNSIGNED_INT_IMAGE_2D := new GlslTypeToken($9063);
private static _UNSIGNED_INT_IMAGE_3D := new GlslTypeToken($9064);
private static _UNSIGNED_INT_IMAGE_2D_RECT := new GlslTypeToken($9065);
private static _UNSIGNED_INT_IMAGE_CUBE := new GlslTypeToken($9066);
private static _UNSIGNED_INT_IMAGE_BUFFER := new GlslTypeToken($9067);
private static _UNSIGNED_INT_IMAGE_1D_ARRAY := new GlslTypeToken($9068);
private static _UNSIGNED_INT_IMAGE_2D_ARRAY := new GlslTypeToken($9069);
private static _UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY := new GlslTypeToken($906A);
private static _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE := new GlslTypeToken($906B);
private static _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($906C);
private static _SAMPLER_2D_MULTISAMPLE := new GlslTypeToken($9108);
private static _INT_SAMPLER_2D_MULTISAMPLE := new GlslTypeToken($9109);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE := new GlslTypeToken($910A);
private static _SAMPLER_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($910B);
private static _INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($910C);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new GlslTypeToken($910D);
private static _UNSIGNED_INT_ATOMIC_COUNTER := new GlslTypeToken($92DB);
public static property INT: GlslTypeToken read _INT;
public static property UNSIGNED_INT: GlslTypeToken read _UNSIGNED_INT;
public static property FLOAT: GlslTypeToken read _FLOAT;
public static property DOUBLE: GlslTypeToken read _DOUBLE;
public static property FLOAT_VEC2: GlslTypeToken read _FLOAT_VEC2;
public static property FLOAT_VEC3: GlslTypeToken read _FLOAT_VEC3;
public static property FLOAT_VEC4: GlslTypeToken read _FLOAT_VEC4;
public static property INT_VEC2: GlslTypeToken read _INT_VEC2;
public static property INT_VEC3: GlslTypeToken read _INT_VEC3;
public static property INT_VEC4: GlslTypeToken read _INT_VEC4;
public static property BOOL: GlslTypeToken read _BOOL;
public static property BOOL_VEC2: GlslTypeToken read _BOOL_VEC2;
public static property BOOL_VEC3: GlslTypeToken read _BOOL_VEC3;
public static property BOOL_VEC4: GlslTypeToken read _BOOL_VEC4;
public static property FLOAT_MAT2: GlslTypeToken read _FLOAT_MAT2;
public static property FLOAT_MAT3: GlslTypeToken read _FLOAT_MAT3;
public static property FLOAT_MAT4: GlslTypeToken read _FLOAT_MAT4;
public static property SAMPLER_1D: GlslTypeToken read _SAMPLER_1D;
public static property SAMPLER_2D: GlslTypeToken read _SAMPLER_2D;
public static property SAMPLER_3D: GlslTypeToken read _SAMPLER_3D;
public static property SAMPLER_CUBE: GlslTypeToken read _SAMPLER_CUBE;
public static property SAMPLER_1D_SHADOW: GlslTypeToken read _SAMPLER_1D_SHADOW;
public static property SAMPLER_2D_SHADOW: GlslTypeToken read _SAMPLER_2D_SHADOW;
public static property SAMPLER_2D_RECT: GlslTypeToken read _SAMPLER_2D_RECT;
public static property SAMPLER_2D_RECT_SHADOW: GlslTypeToken read _SAMPLER_2D_RECT_SHADOW;
public static property FLOAT_MAT2x3: GlslTypeToken read _FLOAT_MAT2x3;
public static property FLOAT_MAT2x4: GlslTypeToken read _FLOAT_MAT2x4;
public static property FLOAT_MAT3x2: GlslTypeToken read _FLOAT_MAT3x2;
public static property FLOAT_MAT3x4: GlslTypeToken read _FLOAT_MAT3x4;
public static property FLOAT_MAT4x2: GlslTypeToken read _FLOAT_MAT4x2;
public static property FLOAT_MAT4x3: GlslTypeToken read _FLOAT_MAT4x3;
public static property SAMPLER_1D_ARRAY: GlslTypeToken read _SAMPLER_1D_ARRAY;
public static property SAMPLER_2D_ARRAY: GlslTypeToken read _SAMPLER_2D_ARRAY;
public static property SAMPLER_BUFFER: GlslTypeToken read _SAMPLER_BUFFER;
public static property SAMPLER_1D_ARRAY_SHADOW: GlslTypeToken read _SAMPLER_1D_ARRAY_SHADOW;
public static property SAMPLER_2D_ARRAY_SHADOW: GlslTypeToken read _SAMPLER_2D_ARRAY_SHADOW;
public static property SAMPLER_CUBE_SHADOW: GlslTypeToken read _SAMPLER_CUBE_SHADOW;
public static property UNSIGNED_INT_VEC2: GlslTypeToken read _UNSIGNED_INT_VEC2;
public static property UNSIGNED_INT_VEC3: GlslTypeToken read _UNSIGNED_INT_VEC3;
public static property UNSIGNED_INT_VEC4: GlslTypeToken read _UNSIGNED_INT_VEC4;
public static property INT_SAMPLER_1D: GlslTypeToken read _INT_SAMPLER_1D;
public static property INT_SAMPLER_2D: GlslTypeToken read _INT_SAMPLER_2D;
public static property INT_SAMPLER_3D: GlslTypeToken read _INT_SAMPLER_3D;
public static property INT_SAMPLER_CUBE: GlslTypeToken read _INT_SAMPLER_CUBE;
public static property INT_SAMPLER_2D_RECT: GlslTypeToken read _INT_SAMPLER_2D_RECT;
public static property INT_SAMPLER_1D_ARRAY: GlslTypeToken read _INT_SAMPLER_1D_ARRAY;
public static property INT_SAMPLER_2D_ARRAY: GlslTypeToken read _INT_SAMPLER_2D_ARRAY;
public static property INT_SAMPLER_BUFFER: GlslTypeToken read _INT_SAMPLER_BUFFER;
public static property UNSIGNED_INT_SAMPLER_1D: GlslTypeToken read _UNSIGNED_INT_SAMPLER_1D;
public static property UNSIGNED_INT_SAMPLER_2D: GlslTypeToken read _UNSIGNED_INT_SAMPLER_2D;
public static property UNSIGNED_INT_SAMPLER_3D: GlslTypeToken read _UNSIGNED_INT_SAMPLER_3D;
public static property UNSIGNED_INT_SAMPLER_CUBE: GlslTypeToken read _UNSIGNED_INT_SAMPLER_CUBE;
public static property UNSIGNED_INT_SAMPLER_2D_RECT: GlslTypeToken read _UNSIGNED_INT_SAMPLER_2D_RECT;
public static property UNSIGNED_INT_SAMPLER_1D_ARRAY: GlslTypeToken read _UNSIGNED_INT_SAMPLER_1D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_ARRAY: GlslTypeToken read _UNSIGNED_INT_SAMPLER_2D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_BUFFER: GlslTypeToken read _UNSIGNED_INT_SAMPLER_BUFFER;
public static property DOUBLE_MAT2: GlslTypeToken read _DOUBLE_MAT2;
public static property DOUBLE_MAT3: GlslTypeToken read _DOUBLE_MAT3;
public static property DOUBLE_MAT4: GlslTypeToken read _DOUBLE_MAT4;
public static property DOUBLE_VEC2: GlslTypeToken read _DOUBLE_VEC2;
public static property DOUBLE_VEC3: GlslTypeToken read _DOUBLE_VEC3;
public static property DOUBLE_VEC4: GlslTypeToken read _DOUBLE_VEC4;
public static property SAMPLER_CUBE_MAP_ARRAY: GlslTypeToken read _SAMPLER_CUBE_MAP_ARRAY;
public static property SAMPLER_CUBE_MAP_ARRAY_SHADOW: GlslTypeToken read _SAMPLER_CUBE_MAP_ARRAY_SHADOW;
public static property INT_SAMPLER_CUBE_MAP_ARRAY: GlslTypeToken read _INT_SAMPLER_CUBE_MAP_ARRAY;
public static property UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: GlslTypeToken read _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY;
public static property IMAGE_1D: GlslTypeToken read _IMAGE_1D;
public static property IMAGE_2D: GlslTypeToken read _IMAGE_2D;
public static property IMAGE_3D: GlslTypeToken read _IMAGE_3D;
public static property IMAGE_2D_RECT: GlslTypeToken read _IMAGE_2D_RECT;
public static property IMAGE_CUBE: GlslTypeToken read _IMAGE_CUBE;
public static property IMAGE_BUFFER: GlslTypeToken read _IMAGE_BUFFER;
public static property IMAGE_1D_ARRAY: GlslTypeToken read _IMAGE_1D_ARRAY;
public static property IMAGE_2D_ARRAY: GlslTypeToken read _IMAGE_2D_ARRAY;
public static property IMAGE_CUBE_MAP_ARRAY: GlslTypeToken read _IMAGE_CUBE_MAP_ARRAY;
public static property IMAGE_2D_MULTISAMPLE: GlslTypeToken read _IMAGE_2D_MULTISAMPLE;
public static property IMAGE_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _IMAGE_2D_MULTISAMPLE_ARRAY;
public static property INT_IMAGE_1D: GlslTypeToken read _INT_IMAGE_1D;
public static property INT_IMAGE_2D: GlslTypeToken read _INT_IMAGE_2D;
public static property INT_IMAGE_3D: GlslTypeToken read _INT_IMAGE_3D;
public static property INT_IMAGE_2D_RECT: GlslTypeToken read _INT_IMAGE_2D_RECT;
public static property INT_IMAGE_CUBE: GlslTypeToken read _INT_IMAGE_CUBE;
public static property INT_IMAGE_BUFFER: GlslTypeToken read _INT_IMAGE_BUFFER;
public static property INT_IMAGE_1D_ARRAY: GlslTypeToken read _INT_IMAGE_1D_ARRAY;
public static property INT_IMAGE_2D_ARRAY: GlslTypeToken read _INT_IMAGE_2D_ARRAY;
public static property INT_IMAGE_CUBE_MAP_ARRAY: GlslTypeToken read _INT_IMAGE_CUBE_MAP_ARRAY;
public static property INT_IMAGE_2D_MULTISAMPLE: GlslTypeToken read _INT_IMAGE_2D_MULTISAMPLE;
public static property INT_IMAGE_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _INT_IMAGE_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_IMAGE_1D: GlslTypeToken read _UNSIGNED_INT_IMAGE_1D;
public static property UNSIGNED_INT_IMAGE_2D: GlslTypeToken read _UNSIGNED_INT_IMAGE_2D;
public static property UNSIGNED_INT_IMAGE_3D: GlslTypeToken read _UNSIGNED_INT_IMAGE_3D;
public static property UNSIGNED_INT_IMAGE_2D_RECT: GlslTypeToken read _UNSIGNED_INT_IMAGE_2D_RECT;
public static property UNSIGNED_INT_IMAGE_CUBE: GlslTypeToken read _UNSIGNED_INT_IMAGE_CUBE;
public static property UNSIGNED_INT_IMAGE_BUFFER: GlslTypeToken read _UNSIGNED_INT_IMAGE_BUFFER;
public static property UNSIGNED_INT_IMAGE_1D_ARRAY: GlslTypeToken read _UNSIGNED_INT_IMAGE_1D_ARRAY;
public static property UNSIGNED_INT_IMAGE_2D_ARRAY: GlslTypeToken read _UNSIGNED_INT_IMAGE_2D_ARRAY;
public static property UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY: GlslTypeToken read _UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY;
public static property UNSIGNED_INT_IMAGE_2D_MULTISAMPLE: GlslTypeToken read _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
public static property UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY;
public static property SAMPLER_2D_MULTISAMPLE: GlslTypeToken read _SAMPLER_2D_MULTISAMPLE;
public static property INT_SAMPLER_2D_MULTISAMPLE: GlslTypeToken read _INT_SAMPLER_2D_MULTISAMPLE;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: GlslTypeToken read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
public static property SAMPLER_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property INT_SAMPLER_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: GlslTypeToken read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_ATOMIC_COUNTER: GlslTypeToken read _UNSIGNED_INT_ATOMIC_COUNTER;
public function ToString: string; override;
begin
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($8B50) then Result := 'FLOAT_VEC2' else
if self.val = UInt32($8B51) then Result := 'FLOAT_VEC3' else
if self.val = UInt32($8B52) then Result := 'FLOAT_VEC4' else
if self.val = UInt32($8B53) then Result := 'INT_VEC2' else
if self.val = UInt32($8B54) then Result := 'INT_VEC3' else
if self.val = UInt32($8B55) then Result := 'INT_VEC4' else
if self.val = UInt32($8B56) then Result := 'BOOL' else
if self.val = UInt32($8B57) then Result := 'BOOL_VEC2' else
if self.val = UInt32($8B58) then Result := 'BOOL_VEC3' else
if self.val = UInt32($8B59) then Result := 'BOOL_VEC4' else
if self.val = UInt32($8B5A) then Result := 'FLOAT_MAT2' else
if self.val = UInt32($8B5B) then Result := 'FLOAT_MAT3' else
if self.val = UInt32($8B5C) then Result := 'FLOAT_MAT4' else
if self.val = UInt32($8B5D) then Result := 'SAMPLER_1D' else
if self.val = UInt32($8B5E) then Result := 'SAMPLER_2D' else
if self.val = UInt32($8B5F) then Result := 'SAMPLER_3D' else
if self.val = UInt32($8B60) then Result := 'SAMPLER_CUBE' else
if self.val = UInt32($8B61) then Result := 'SAMPLER_1D_SHADOW' else
if self.val = UInt32($8B62) then Result := 'SAMPLER_2D_SHADOW' else
if self.val = UInt32($8B63) then Result := 'SAMPLER_2D_RECT' else
if self.val = UInt32($8B64) then Result := 'SAMPLER_2D_RECT_SHADOW' else
if self.val = UInt32($8B65) then Result := 'FLOAT_MAT2x3' else
if self.val = UInt32($8B66) then Result := 'FLOAT_MAT2x4' else
if self.val = UInt32($8B67) then Result := 'FLOAT_MAT3x2' else
if self.val = UInt32($8B68) then Result := 'FLOAT_MAT3x4' else
if self.val = UInt32($8B69) then Result := 'FLOAT_MAT4x2' else
if self.val = UInt32($8B6A) then Result := 'FLOAT_MAT4x3' else
if self.val = UInt32($8DC0) then Result := 'SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DC1) then Result := 'SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DC2) then Result := 'SAMPLER_BUFFER' else
if self.val = UInt32($8DC3) then Result := 'SAMPLER_1D_ARRAY_SHADOW' else
if self.val = UInt32($8DC4) then Result := 'SAMPLER_2D_ARRAY_SHADOW' else
if self.val = UInt32($8DC5) then Result := 'SAMPLER_CUBE_SHADOW' else
if self.val = UInt32($8DC6) then Result := 'UNSIGNED_INT_VEC2' else
if self.val = UInt32($8DC7) then Result := 'UNSIGNED_INT_VEC3' else
if self.val = UInt32($8DC8) then Result := 'UNSIGNED_INT_VEC4' else
if self.val = UInt32($8DC9) then Result := 'INT_SAMPLER_1D' else
if self.val = UInt32($8DCA) then Result := 'INT_SAMPLER_2D' else
if self.val = UInt32($8DCB) then Result := 'INT_SAMPLER_3D' else
if self.val = UInt32($8DCC) then Result := 'INT_SAMPLER_CUBE' else
if self.val = UInt32($8DCD) then Result := 'INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DCE) then Result := 'INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DCF) then Result := 'INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD0) then Result := 'INT_SAMPLER_BUFFER' else
if self.val = UInt32($8DD1) then Result := 'UNSIGNED_INT_SAMPLER_1D' else
if self.val = UInt32($8DD2) then Result := 'UNSIGNED_INT_SAMPLER_2D' else
if self.val = UInt32($8DD3) then Result := 'UNSIGNED_INT_SAMPLER_3D' else
if self.val = UInt32($8DD4) then Result := 'UNSIGNED_INT_SAMPLER_CUBE' else
if self.val = UInt32($8DD5) then Result := 'UNSIGNED_INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DD6) then Result := 'UNSIGNED_INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DD7) then Result := 'UNSIGNED_INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD8) then Result := 'UNSIGNED_INT_SAMPLER_BUFFER' else
if self.val = UInt32($8F46) then Result := 'DOUBLE_MAT2' else
if self.val = UInt32($8F47) then Result := 'DOUBLE_MAT3' else
if self.val = UInt32($8F48) then Result := 'DOUBLE_MAT4' else
if self.val = UInt32($8FFC) then Result := 'DOUBLE_VEC2' else
if self.val = UInt32($8FFD) then Result := 'DOUBLE_VEC3' else
if self.val = UInt32($8FFE) then Result := 'DOUBLE_VEC4' else
if self.val = UInt32($900C) then Result := 'SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900D) then Result := 'SAMPLER_CUBE_MAP_ARRAY_SHADOW' else
if self.val = UInt32($900E) then Result := 'INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900F) then Result := 'UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($904C) then Result := 'IMAGE_1D' else
if self.val = UInt32($904D) then Result := 'IMAGE_2D' else
if self.val = UInt32($904E) then Result := 'IMAGE_3D' else
if self.val = UInt32($904F) then Result := 'IMAGE_2D_RECT' else
if self.val = UInt32($9050) then Result := 'IMAGE_CUBE' else
if self.val = UInt32($9051) then Result := 'IMAGE_BUFFER' else
if self.val = UInt32($9052) then Result := 'IMAGE_1D_ARRAY' else
if self.val = UInt32($9053) then Result := 'IMAGE_2D_ARRAY' else
if self.val = UInt32($9054) then Result := 'IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9055) then Result := 'IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($9056) then Result := 'IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9057) then Result := 'INT_IMAGE_1D' else
if self.val = UInt32($9058) then Result := 'INT_IMAGE_2D' else
if self.val = UInt32($9059) then Result := 'INT_IMAGE_3D' else
if self.val = UInt32($905A) then Result := 'INT_IMAGE_2D_RECT' else
if self.val = UInt32($905B) then Result := 'INT_IMAGE_CUBE' else
if self.val = UInt32($905C) then Result := 'INT_IMAGE_BUFFER' else
if self.val = UInt32($905D) then Result := 'INT_IMAGE_1D_ARRAY' else
if self.val = UInt32($905E) then Result := 'INT_IMAGE_2D_ARRAY' else
if self.val = UInt32($905F) then Result := 'INT_IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9060) then Result := 'INT_IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($9061) then Result := 'INT_IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9062) then Result := 'UNSIGNED_INT_IMAGE_1D' else
if self.val = UInt32($9063) then Result := 'UNSIGNED_INT_IMAGE_2D' else
if self.val = UInt32($9064) then Result := 'UNSIGNED_INT_IMAGE_3D' else
if self.val = UInt32($9065) then Result := 'UNSIGNED_INT_IMAGE_2D_RECT' else
if self.val = UInt32($9066) then Result := 'UNSIGNED_INT_IMAGE_CUBE' else
if self.val = UInt32($9067) then Result := 'UNSIGNED_INT_IMAGE_BUFFER' else
if self.val = UInt32($9068) then Result := 'UNSIGNED_INT_IMAGE_1D_ARRAY' else
if self.val = UInt32($9069) then Result := 'UNSIGNED_INT_IMAGE_2D_ARRAY' else
if self.val = UInt32($906A) then Result := 'UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY' else
if self.val = UInt32($906B) then Result := 'UNSIGNED_INT_IMAGE_2D_MULTISAMPLE' else
if self.val = UInt32($906C) then Result := 'UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9108) then Result := 'SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($9109) then Result := 'INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910A) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910B) then Result := 'SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910C) then Result := 'INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910D) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($92DB) then Result := 'UNSIGNED_INT_ATOMIC_COUNTER' else
Result := self.val.ToString;
end;
end;
GraphicsResetStatus = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NO_ERROR := new GraphicsResetStatus($0000);
private static _GUILTY_CONTEXT_RESET := new GraphicsResetStatus($8253);
private static _INNOCENT_CONTEXT_RESET := new GraphicsResetStatus($8254);
private static _UNKNOWN_CONTEXT_RESET := new GraphicsResetStatus($8255);
public static property NO_ERROR: GraphicsResetStatus read _NO_ERROR;
public static property GUILTY_CONTEXT_RESET: GraphicsResetStatus read _GUILTY_CONTEXT_RESET;
public static property INNOCENT_CONTEXT_RESET: GraphicsResetStatus read _INNOCENT_CONTEXT_RESET;
public static property UNKNOWN_CONTEXT_RESET: GraphicsResetStatus read _UNKNOWN_CONTEXT_RESET;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NO_ERROR' else
if self.val = UInt32($8253) then Result := 'GUILTY_CONTEXT_RESET' else
if self.val = UInt32($8254) then Result := 'INNOCENT_CONTEXT_RESET' else
if self.val = UInt32($8255) then Result := 'UNKNOWN_CONTEXT_RESET' else
Result := self.val.ToString;
end;
end;
HintMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DONT_CARE := new HintMode($1100);
private static _FASTEST := new HintMode($1101);
private static _NICEST := new HintMode($1102);
public static property DONT_CARE: HintMode read _DONT_CARE;
public static property FASTEST: HintMode read _FASTEST;
public static property NICEST: HintMode read _NICEST;
public function ToString: string; override;
begin
if self.val = UInt32($1100) then Result := 'DONT_CARE' else
if self.val = UInt32($1101) then Result := 'FASTEST' else
if self.val = UInt32($1102) then Result := 'NICEST' else
Result := self.val.ToString;
end;
end;
HintTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PERSPECTIVE_CORRECTION_HINT := new HintTarget($0C50);
private static _POINT_SMOOTH_HINT := new HintTarget($0C51);
private static _LINE_SMOOTH_HINT := new HintTarget($0C52);
private static _POLYGON_SMOOTH_HINT := new HintTarget($0C53);
private static _FOG_HINT := new HintTarget($0C54);
private static _PACK_CMYK_HINT_EXT := new HintTarget($800E);
private static _UNPACK_CMYK_HINT_EXT := new HintTarget($800F);
private static _PHONG_HINT_WIN := new HintTarget($80EB);
private static _CLIP_VOLUME_CLIPPING_HINT_EXT := new HintTarget($80F0);
private static _TEXTURE_MULTI_BUFFER_HINT_SGIX := new HintTarget($812E);
private static _GENERATE_MIPMAP_HINT := new HintTarget($8192);
private static _GENERATE_MIPMAP_HINT_SGIS := new HintTarget($8192);
private static _PROGRAM_BINARY_RETRIEVABLE_HINT := new HintTarget($8257);
private static _CONVOLUTION_HINT_SGIX := new HintTarget($8316);
private static _SCALEBIAS_HINT_SGIX := new HintTarget($8322);
private static _LINE_QUALITY_HINT_SGIX := new HintTarget($835B);
private static _VERTEX_PRECLIP_SGIX := new HintTarget($83EE);
private static _VERTEX_PRECLIP_HINT_SGIX := new HintTarget($83EF);
private static _TEXTURE_COMPRESSION_HINT := new HintTarget($84EF);
private static _TEXTURE_COMPRESSION_HINT_ARB := new HintTarget($84EF);
private static _VERTEX_ARRAY_STORAGE_HINT_APPLE := new HintTarget($851F);
private static _MULTISAMPLE_FILTER_HINT_NV := new HintTarget($8534);
private static _TRANSFORM_HINT_APPLE := new HintTarget($85B1);
private static _TEXTURE_STORAGE_HINT_APPLE := new HintTarget($85BC);
private static _FRAGMENT_SHADER_DERIVATIVE_HINT := new HintTarget($8B8B);
private static _FRAGMENT_SHADER_DERIVATIVE_HINT_ARB := new HintTarget($8B8B);
private static _FRAGMENT_SHADER_DERIVATIVE_HINT_OES := new HintTarget($8B8B);
private static _BINNING_CONTROL_HINT_QCOM := new HintTarget($8FB0);
private static _PREFER_DOUBLEBUFFER_HINT_PGI := new HintTarget($1A1F8);
private static _CONSERVE_MEMORY_HINT_PGI := new HintTarget($1A1FD);
private static _RECLAIM_MEMORY_HINT_PGI := new HintTarget($1A1FE);
private static _NATIVE_GRAPHICS_BEGIN_HINT_PGI := new HintTarget($1A203);
private static _NATIVE_GRAPHICS_END_HINT_PGI := new HintTarget($1A204);
private static _ALWAYS_FAST_HINT_PGI := new HintTarget($1A20C);
private static _ALWAYS_SOFT_HINT_PGI := new HintTarget($1A20D);
private static _ALLOW_DRAW_OBJ_HINT_PGI := new HintTarget($1A20E);
private static _ALLOW_DRAW_WIN_HINT_PGI := new HintTarget($1A20F);
private static _ALLOW_DRAW_FRG_HINT_PGI := new HintTarget($1A210);
private static _ALLOW_DRAW_MEM_HINT_PGI := new HintTarget($1A211);
private static _STRICT_DEPTHFUNC_HINT_PGI := new HintTarget($1A216);
private static _STRICT_LIGHTING_HINT_PGI := new HintTarget($1A217);
private static _STRICT_SCISSOR_HINT_PGI := new HintTarget($1A218);
private static _FULL_STIPPLE_HINT_PGI := new HintTarget($1A219);
private static _CLIP_NEAR_HINT_PGI := new HintTarget($1A220);
private static _CLIP_FAR_HINT_PGI := new HintTarget($1A221);
private static _WIDE_LINE_HINT_PGI := new HintTarget($1A222);
private static _BACK_NORMALS_HINT_PGI := new HintTarget($1A223);
private static _VERTEX_DATA_HINT_PGI := new HintTarget($1A22A);
private static _VERTEX_CONSISTENT_HINT_PGI := new HintTarget($1A22B);
private static _MATERIAL_SIDE_HINT_PGI := new HintTarget($1A22C);
private static _MAX_VERTEX_HINT_PGI := new HintTarget($1A22D);
public static property PERSPECTIVE_CORRECTION_HINT: HintTarget read _PERSPECTIVE_CORRECTION_HINT;
public static property POINT_SMOOTH_HINT: HintTarget read _POINT_SMOOTH_HINT;
public static property LINE_SMOOTH_HINT: HintTarget read _LINE_SMOOTH_HINT;
public static property POLYGON_SMOOTH_HINT: HintTarget read _POLYGON_SMOOTH_HINT;
public static property FOG_HINT: HintTarget read _FOG_HINT;
public static property PACK_CMYK_HINT_EXT: HintTarget read _PACK_CMYK_HINT_EXT;
public static property UNPACK_CMYK_HINT_EXT: HintTarget read _UNPACK_CMYK_HINT_EXT;
public static property PHONG_HINT_WIN: HintTarget read _PHONG_HINT_WIN;
public static property CLIP_VOLUME_CLIPPING_HINT_EXT: HintTarget read _CLIP_VOLUME_CLIPPING_HINT_EXT;
public static property TEXTURE_MULTI_BUFFER_HINT_SGIX: HintTarget read _TEXTURE_MULTI_BUFFER_HINT_SGIX;
public static property GENERATE_MIPMAP_HINT: HintTarget read _GENERATE_MIPMAP_HINT;
public static property GENERATE_MIPMAP_HINT_SGIS: HintTarget read _GENERATE_MIPMAP_HINT_SGIS;
public static property PROGRAM_BINARY_RETRIEVABLE_HINT: HintTarget read _PROGRAM_BINARY_RETRIEVABLE_HINT;
public static property CONVOLUTION_HINT_SGIX: HintTarget read _CONVOLUTION_HINT_SGIX;
public static property SCALEBIAS_HINT_SGIX: HintTarget read _SCALEBIAS_HINT_SGIX;
public static property LINE_QUALITY_HINT_SGIX: HintTarget read _LINE_QUALITY_HINT_SGIX;
public static property VERTEX_PRECLIP_SGIX: HintTarget read _VERTEX_PRECLIP_SGIX;
public static property VERTEX_PRECLIP_HINT_SGIX: HintTarget read _VERTEX_PRECLIP_HINT_SGIX;
public static property TEXTURE_COMPRESSION_HINT: HintTarget read _TEXTURE_COMPRESSION_HINT;
public static property TEXTURE_COMPRESSION_HINT_ARB: HintTarget read _TEXTURE_COMPRESSION_HINT_ARB;
public static property VERTEX_ARRAY_STORAGE_HINT_APPLE: HintTarget read _VERTEX_ARRAY_STORAGE_HINT_APPLE;
public static property MULTISAMPLE_FILTER_HINT_NV: HintTarget read _MULTISAMPLE_FILTER_HINT_NV;
public static property TRANSFORM_HINT_APPLE: HintTarget read _TRANSFORM_HINT_APPLE;
public static property TEXTURE_STORAGE_HINT_APPLE: HintTarget read _TEXTURE_STORAGE_HINT_APPLE;
public static property FRAGMENT_SHADER_DERIVATIVE_HINT: HintTarget read _FRAGMENT_SHADER_DERIVATIVE_HINT;
public static property FRAGMENT_SHADER_DERIVATIVE_HINT_ARB: HintTarget read _FRAGMENT_SHADER_DERIVATIVE_HINT_ARB;
public static property FRAGMENT_SHADER_DERIVATIVE_HINT_OES: HintTarget read _FRAGMENT_SHADER_DERIVATIVE_HINT_OES;
public static property BINNING_CONTROL_HINT_QCOM: HintTarget read _BINNING_CONTROL_HINT_QCOM;
public static property PREFER_DOUBLEBUFFER_HINT_PGI: HintTarget read _PREFER_DOUBLEBUFFER_HINT_PGI;
public static property CONSERVE_MEMORY_HINT_PGI: HintTarget read _CONSERVE_MEMORY_HINT_PGI;
public static property RECLAIM_MEMORY_HINT_PGI: HintTarget read _RECLAIM_MEMORY_HINT_PGI;
public static property NATIVE_GRAPHICS_BEGIN_HINT_PGI: HintTarget read _NATIVE_GRAPHICS_BEGIN_HINT_PGI;
public static property NATIVE_GRAPHICS_END_HINT_PGI: HintTarget read _NATIVE_GRAPHICS_END_HINT_PGI;
public static property ALWAYS_FAST_HINT_PGI: HintTarget read _ALWAYS_FAST_HINT_PGI;
public static property ALWAYS_SOFT_HINT_PGI: HintTarget read _ALWAYS_SOFT_HINT_PGI;
public static property ALLOW_DRAW_OBJ_HINT_PGI: HintTarget read _ALLOW_DRAW_OBJ_HINT_PGI;
public static property ALLOW_DRAW_WIN_HINT_PGI: HintTarget read _ALLOW_DRAW_WIN_HINT_PGI;
public static property ALLOW_DRAW_FRG_HINT_PGI: HintTarget read _ALLOW_DRAW_FRG_HINT_PGI;
public static property ALLOW_DRAW_MEM_HINT_PGI: HintTarget read _ALLOW_DRAW_MEM_HINT_PGI;
public static property STRICT_DEPTHFUNC_HINT_PGI: HintTarget read _STRICT_DEPTHFUNC_HINT_PGI;
public static property STRICT_LIGHTING_HINT_PGI: HintTarget read _STRICT_LIGHTING_HINT_PGI;
public static property STRICT_SCISSOR_HINT_PGI: HintTarget read _STRICT_SCISSOR_HINT_PGI;
public static property FULL_STIPPLE_HINT_PGI: HintTarget read _FULL_STIPPLE_HINT_PGI;
public static property CLIP_NEAR_HINT_PGI: HintTarget read _CLIP_NEAR_HINT_PGI;
public static property CLIP_FAR_HINT_PGI: HintTarget read _CLIP_FAR_HINT_PGI;
public static property WIDE_LINE_HINT_PGI: HintTarget read _WIDE_LINE_HINT_PGI;
public static property BACK_NORMALS_HINT_PGI: HintTarget read _BACK_NORMALS_HINT_PGI;
public static property VERTEX_DATA_HINT_PGI: HintTarget read _VERTEX_DATA_HINT_PGI;
public static property VERTEX_CONSISTENT_HINT_PGI: HintTarget read _VERTEX_CONSISTENT_HINT_PGI;
public static property MATERIAL_SIDE_HINT_PGI: HintTarget read _MATERIAL_SIDE_HINT_PGI;
public static property MAX_VERTEX_HINT_PGI: HintTarget read _MAX_VERTEX_HINT_PGI;
public function ToString: string; override;
begin
if self.val = UInt32($0C50) then Result := 'PERSPECTIVE_CORRECTION_HINT' else
if self.val = UInt32($0C51) then Result := 'POINT_SMOOTH_HINT' else
if self.val = UInt32($0C52) then Result := 'LINE_SMOOTH_HINT' else
if self.val = UInt32($0C53) then Result := 'POLYGON_SMOOTH_HINT' else
if self.val = UInt32($0C54) then Result := 'FOG_HINT' else
if self.val = UInt32($800E) then Result := 'PACK_CMYK_HINT_EXT' else
if self.val = UInt32($800F) then Result := 'UNPACK_CMYK_HINT_EXT' else
if self.val = UInt32($80EB) then Result := 'PHONG_HINT_WIN' else
if self.val = UInt32($80F0) then Result := 'CLIP_VOLUME_CLIPPING_HINT_EXT' else
if self.val = UInt32($812E) then Result := 'TEXTURE_MULTI_BUFFER_HINT_SGIX' else
if self.val = UInt32($8192) then Result := 'GENERATE_MIPMAP_HINT' else
if self.val = UInt32($8192) then Result := 'GENERATE_MIPMAP_HINT_SGIS' else
if self.val = UInt32($8257) then Result := 'PROGRAM_BINARY_RETRIEVABLE_HINT' else
if self.val = UInt32($8316) then Result := 'CONVOLUTION_HINT_SGIX' else
if self.val = UInt32($8322) then Result := 'SCALEBIAS_HINT_SGIX' else
if self.val = UInt32($835B) then Result := 'LINE_QUALITY_HINT_SGIX' else
if self.val = UInt32($83EE) then Result := 'VERTEX_PRECLIP_SGIX' else
if self.val = UInt32($83EF) then Result := 'VERTEX_PRECLIP_HINT_SGIX' else
if self.val = UInt32($84EF) then Result := 'TEXTURE_COMPRESSION_HINT' else
if self.val = UInt32($84EF) then Result := 'TEXTURE_COMPRESSION_HINT_ARB' else
if self.val = UInt32($851F) then Result := 'VERTEX_ARRAY_STORAGE_HINT_APPLE' else
if self.val = UInt32($8534) then Result := 'MULTISAMPLE_FILTER_HINT_NV' else
if self.val = UInt32($85B1) then Result := 'TRANSFORM_HINT_APPLE' else
if self.val = UInt32($85BC) then Result := 'TEXTURE_STORAGE_HINT_APPLE' else
if self.val = UInt32($8B8B) then Result := 'FRAGMENT_SHADER_DERIVATIVE_HINT' else
if self.val = UInt32($8B8B) then Result := 'FRAGMENT_SHADER_DERIVATIVE_HINT_ARB' else
if self.val = UInt32($8B8B) then Result := 'FRAGMENT_SHADER_DERIVATIVE_HINT_OES' else
if self.val = UInt32($8FB0) then Result := 'BINNING_CONTROL_HINT_QCOM' else
if self.val = UInt32($1A1F8) then Result := 'PREFER_DOUBLEBUFFER_HINT_PGI' else
if self.val = UInt32($1A1FD) then Result := 'CONSERVE_MEMORY_HINT_PGI' else
if self.val = UInt32($1A1FE) then Result := 'RECLAIM_MEMORY_HINT_PGI' else
if self.val = UInt32($1A203) then Result := 'NATIVE_GRAPHICS_BEGIN_HINT_PGI' else
if self.val = UInt32($1A204) then Result := 'NATIVE_GRAPHICS_END_HINT_PGI' else
if self.val = UInt32($1A20C) then Result := 'ALWAYS_FAST_HINT_PGI' else
if self.val = UInt32($1A20D) then Result := 'ALWAYS_SOFT_HINT_PGI' else
if self.val = UInt32($1A20E) then Result := 'ALLOW_DRAW_OBJ_HINT_PGI' else
if self.val = UInt32($1A20F) then Result := 'ALLOW_DRAW_WIN_HINT_PGI' else
if self.val = UInt32($1A210) then Result := 'ALLOW_DRAW_FRG_HINT_PGI' else
if self.val = UInt32($1A211) then Result := 'ALLOW_DRAW_MEM_HINT_PGI' else
if self.val = UInt32($1A216) then Result := 'STRICT_DEPTHFUNC_HINT_PGI' else
if self.val = UInt32($1A217) then Result := 'STRICT_LIGHTING_HINT_PGI' else
if self.val = UInt32($1A218) then Result := 'STRICT_SCISSOR_HINT_PGI' else
if self.val = UInt32($1A219) then Result := 'FULL_STIPPLE_HINT_PGI' else
if self.val = UInt32($1A220) then Result := 'CLIP_NEAR_HINT_PGI' else
if self.val = UInt32($1A221) then Result := 'CLIP_FAR_HINT_PGI' else
if self.val = UInt32($1A222) then Result := 'WIDE_LINE_HINT_PGI' else
if self.val = UInt32($1A223) then Result := 'BACK_NORMALS_HINT_PGI' else
if self.val = UInt32($1A22A) then Result := 'VERTEX_DATA_HINT_PGI' else
if self.val = UInt32($1A22B) then Result := 'VERTEX_CONSISTENT_HINT_PGI' else
if self.val = UInt32($1A22C) then Result := 'MATERIAL_SIDE_HINT_PGI' else
if self.val = UInt32($1A22D) then Result := 'MAX_VERTEX_HINT_PGI' else
Result := self.val.ToString;
end;
end;
IndexPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SHORT := new IndexPointerType($1402);
private static _INT := new IndexPointerType($1404);
private static _FLOAT := new IndexPointerType($1406);
private static _DOUBLE := new IndexPointerType($140A);
public static property SHORT: IndexPointerType read _SHORT;
public static property INT: IndexPointerType read _INT;
public static property FLOAT: IndexPointerType read _FLOAT;
public static property DOUBLE: IndexPointerType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
InterleavedArrayFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _V2F := new InterleavedArrayFormat($2A20);
private static _V3F := new InterleavedArrayFormat($2A21);
private static _C4UB_V2F := new InterleavedArrayFormat($2A22);
private static _C4UB_V3F := new InterleavedArrayFormat($2A23);
private static _C3F_V3F := new InterleavedArrayFormat($2A24);
private static _N3F_V3F := new InterleavedArrayFormat($2A25);
private static _C4F_N3F_V3F := new InterleavedArrayFormat($2A26);
private static _T2F_V3F := new InterleavedArrayFormat($2A27);
private static _T4F_V4F := new InterleavedArrayFormat($2A28);
private static _T2F_C4UB_V3F := new InterleavedArrayFormat($2A29);
private static _T2F_C3F_V3F := new InterleavedArrayFormat($2A2A);
private static _T2F_N3F_V3F := new InterleavedArrayFormat($2A2B);
private static _T2F_C4F_N3F_V3F := new InterleavedArrayFormat($2A2C);
private static _T4F_C4F_N3F_V4F := new InterleavedArrayFormat($2A2D);
public static property V2F: InterleavedArrayFormat read _V2F;
public static property V3F: InterleavedArrayFormat read _V3F;
public static property C4UB_V2F: InterleavedArrayFormat read _C4UB_V2F;
public static property C4UB_V3F: InterleavedArrayFormat read _C4UB_V3F;
public static property C3F_V3F: InterleavedArrayFormat read _C3F_V3F;
public static property N3F_V3F: InterleavedArrayFormat read _N3F_V3F;
public static property C4F_N3F_V3F: InterleavedArrayFormat read _C4F_N3F_V3F;
public static property T2F_V3F: InterleavedArrayFormat read _T2F_V3F;
public static property T4F_V4F: InterleavedArrayFormat read _T4F_V4F;
public static property T2F_C4UB_V3F: InterleavedArrayFormat read _T2F_C4UB_V3F;
public static property T2F_C3F_V3F: InterleavedArrayFormat read _T2F_C3F_V3F;
public static property T2F_N3F_V3F: InterleavedArrayFormat read _T2F_N3F_V3F;
public static property T2F_C4F_N3F_V3F: InterleavedArrayFormat read _T2F_C4F_N3F_V3F;
public static property T4F_C4F_N3F_V4F: InterleavedArrayFormat read _T4F_C4F_N3F_V4F;
public function ToString: string; override;
begin
if self.val = UInt32($2A20) then Result := 'V2F' else
if self.val = UInt32($2A21) then Result := 'V3F' else
if self.val = UInt32($2A22) then Result := 'C4UB_V2F' else
if self.val = UInt32($2A23) then Result := 'C4UB_V3F' else
if self.val = UInt32($2A24) then Result := 'C3F_V3F' else
if self.val = UInt32($2A25) then Result := 'N3F_V3F' else
if self.val = UInt32($2A26) then Result := 'C4F_N3F_V3F' else
if self.val = UInt32($2A27) then Result := 'T2F_V3F' else
if self.val = UInt32($2A28) then Result := 'T4F_V4F' else
if self.val = UInt32($2A29) then Result := 'T2F_C4UB_V3F' else
if self.val = UInt32($2A2A) then Result := 'T2F_C3F_V3F' else
if self.val = UInt32($2A2B) then Result := 'T2F_N3F_V3F' else
if self.val = UInt32($2A2C) then Result := 'T2F_C4F_N3F_V3F' else
if self.val = UInt32($2A2D) then Result := 'T4F_C4F_N3F_V4F' else
Result := self.val.ToString;
end;
end;
InternalFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STENCIL_INDEX := new InternalFormat($1901);
private static _STENCIL_INDEX_OES := new InternalFormat($1901);
private static _DEPTH_COMPONENT := new InternalFormat($1902);
private static _RED := new InternalFormat($1903);
private static _RED_EXT := new InternalFormat($1903);
private static _RGB := new InternalFormat($1907);
private static _RGBA := new InternalFormat($1908);
private static _R3_G3_B2 := new InternalFormat($2A10);
private static _ALPHA4 := new InternalFormat($803B);
private static _ALPHA8 := new InternalFormat($803C);
private static _ALPHA12 := new InternalFormat($803D);
private static _ALPHA16 := new InternalFormat($803E);
private static _LUMINANCE4 := new InternalFormat($803F);
private static _LUMINANCE8 := new InternalFormat($8040);
private static _LUMINANCE12 := new InternalFormat($8041);
private static _LUMINANCE16 := new InternalFormat($8042);
private static _LUMINANCE4_ALPHA4 := new InternalFormat($8043);
private static _LUMINANCE6_ALPHA2 := new InternalFormat($8044);
private static _LUMINANCE8_ALPHA8 := new InternalFormat($8045);
private static _LUMINANCE12_ALPHA4 := new InternalFormat($8046);
private static _LUMINANCE12_ALPHA12 := new InternalFormat($8047);
private static _LUMINANCE16_ALPHA16 := new InternalFormat($8048);
private static _INTENSITY := new InternalFormat($8049);
private static _INTENSITY4 := new InternalFormat($804A);
private static _INTENSITY8 := new InternalFormat($804B);
private static _INTENSITY12 := new InternalFormat($804C);
private static _INTENSITY16 := new InternalFormat($804D);
private static _RGB2_EXT := new InternalFormat($804E);
private static _RGB4 := new InternalFormat($804F);
private static _RGB4_EXT := new InternalFormat($804F);
private static _RGB5 := new InternalFormat($8050);
private static _RGB5_EXT := new InternalFormat($8050);
private static _RGB8 := new InternalFormat($8051);
private static _RGB8_EXT := new InternalFormat($8051);
private static _RGB8_OES := new InternalFormat($8051);
private static _RGB10 := new InternalFormat($8052);
private static _RGB10_EXT := new InternalFormat($8052);
private static _RGB12 := new InternalFormat($8053);
private static _RGB12_EXT := new InternalFormat($8053);
private static _RGB16 := new InternalFormat($8054);
private static _RGB16_EXT := new InternalFormat($8054);
private static _RGBA4 := new InternalFormat($8056);
private static _RGBA4_EXT := new InternalFormat($8056);
private static _RGBA4_OES := new InternalFormat($8056);
private static _RGB5_A1 := new InternalFormat($8057);
private static _RGB5_A1_EXT := new InternalFormat($8057);
private static _RGB5_A1_OES := new InternalFormat($8057);
private static _RGBA8 := new InternalFormat($8058);
private static _RGBA8_EXT := new InternalFormat($8058);
private static _RGBA8_OES := new InternalFormat($8058);
private static _RGB10_A2 := new InternalFormat($8059);
private static _RGB10_A2_EXT := new InternalFormat($8059);
private static _RGBA12 := new InternalFormat($805A);
private static _RGBA12_EXT := new InternalFormat($805A);
private static _RGBA16 := new InternalFormat($805B);
private static _RGBA16_EXT := new InternalFormat($805B);
private static _DUAL_ALPHA4_SGIS := new InternalFormat($8110);
private static _DUAL_ALPHA8_SGIS := new InternalFormat($8111);
private static _DUAL_ALPHA12_SGIS := new InternalFormat($8112);
private static _DUAL_ALPHA16_SGIS := new InternalFormat($8113);
private static _DUAL_LUMINANCE4_SGIS := new InternalFormat($8114);
private static _DUAL_LUMINANCE8_SGIS := new InternalFormat($8115);
private static _DUAL_LUMINANCE12_SGIS := new InternalFormat($8116);
private static _DUAL_LUMINANCE16_SGIS := new InternalFormat($8117);
private static _DUAL_INTENSITY4_SGIS := new InternalFormat($8118);
private static _DUAL_INTENSITY8_SGIS := new InternalFormat($8119);
private static _DUAL_INTENSITY12_SGIS := new InternalFormat($811A);
private static _DUAL_INTENSITY16_SGIS := new InternalFormat($811B);
private static _DUAL_LUMINANCE_ALPHA4_SGIS := new InternalFormat($811C);
private static _DUAL_LUMINANCE_ALPHA8_SGIS := new InternalFormat($811D);
private static _QUAD_ALPHA4_SGIS := new InternalFormat($811E);
private static _QUAD_ALPHA8_SGIS := new InternalFormat($811F);
private static _QUAD_LUMINANCE4_SGIS := new InternalFormat($8120);
private static _QUAD_LUMINANCE8_SGIS := new InternalFormat($8121);
private static _QUAD_INTENSITY4_SGIS := new InternalFormat($8122);
private static _QUAD_INTENSITY8_SGIS := new InternalFormat($8123);
private static _DEPTH_COMPONENT16 := new InternalFormat($81A5);
private static _DEPTH_COMPONENT16_ARB := new InternalFormat($81A5);
private static _DEPTH_COMPONENT16_OES := new InternalFormat($81A5);
private static _DEPTH_COMPONENT16_SGIX := new InternalFormat($81A5);
private static _DEPTH_COMPONENT24_ARB := new InternalFormat($81A6);
private static _DEPTH_COMPONENT24_OES := new InternalFormat($81A6);
private static _DEPTH_COMPONENT24_SGIX := new InternalFormat($81A6);
private static _DEPTH_COMPONENT32_ARB := new InternalFormat($81A7);
private static _DEPTH_COMPONENT32_OES := new InternalFormat($81A7);
private static _DEPTH_COMPONENT32_SGIX := new InternalFormat($81A7);
private static _COMPRESSED_RED := new InternalFormat($8225);
private static _COMPRESSED_RG := new InternalFormat($8226);
private static _RG := new InternalFormat($8227);
private static _R8 := new InternalFormat($8229);
private static _R8_EXT := new InternalFormat($8229);
private static _R16 := new InternalFormat($822A);
private static _R16_EXT := new InternalFormat($822A);
private static _RG8 := new InternalFormat($822B);
private static _RG8_EXT := new InternalFormat($822B);
private static _RG16 := new InternalFormat($822C);
private static _RG16_EXT := new InternalFormat($822C);
private static _R16F := new InternalFormat($822D);
private static _R16F_EXT := new InternalFormat($822D);
private static _R32F := new InternalFormat($822E);
private static _R32F_EXT := new InternalFormat($822E);
private static _RG16F := new InternalFormat($822F);
private static _RG16F_EXT := new InternalFormat($822F);
private static _RG32F := new InternalFormat($8230);
private static _RG32F_EXT := new InternalFormat($8230);
private static _R8I := new InternalFormat($8231);
private static _R8UI := new InternalFormat($8232);
private static _R16I := new InternalFormat($8233);
private static _R16UI := new InternalFormat($8234);
private static _R32I := new InternalFormat($8235);
private static _R32UI := new InternalFormat($8236);
private static _RG8I := new InternalFormat($8237);
private static _RG8UI := new InternalFormat($8238);
private static _RG16I := new InternalFormat($8239);
private static _RG16UI := new InternalFormat($823A);
private static _RG32I := new InternalFormat($823B);
private static _RG32UI := new InternalFormat($823C);
private static _COMPRESSED_RGB_S3TC_DXT1_EXT := new InternalFormat($83F0);
private static _COMPRESSED_RGBA_S3TC_DXT1_EXT := new InternalFormat($83F1);
private static _COMPRESSED_RGBA_S3TC_DXT3_EXT := new InternalFormat($83F2);
private static _COMPRESSED_RGBA_S3TC_DXT5_EXT := new InternalFormat($83F3);
private static _COMPRESSED_RGB := new InternalFormat($84ED);
private static _COMPRESSED_RGBA := new InternalFormat($84EE);
private static _DEPTH_STENCIL := new InternalFormat($84F9);
private static _DEPTH_STENCIL_EXT := new InternalFormat($84F9);
private static _DEPTH_STENCIL_NV := new InternalFormat($84F9);
private static _DEPTH_STENCIL_OES := new InternalFormat($84F9);
private static _DEPTH_STENCIL_MESA := new InternalFormat($8750);
private static _RGBA32F := new InternalFormat($8814);
private static _RGBA32F_ARB := new InternalFormat($8814);
private static _RGBA32F_EXT := new InternalFormat($8814);
private static _RGB32F := new InternalFormat($8815);
private static _RGBA16F := new InternalFormat($881A);
private static _RGBA16F_ARB := new InternalFormat($881A);
private static _RGBA16F_EXT := new InternalFormat($881A);
private static _RGB16F := new InternalFormat($881B);
private static _RGB16F_ARB := new InternalFormat($881B);
private static _RGB16F_EXT := new InternalFormat($881B);
private static _DEPTH24_STENCIL8 := new InternalFormat($88F0);
private static _DEPTH24_STENCIL8_EXT := new InternalFormat($88F0);
private static _DEPTH24_STENCIL8_OES := new InternalFormat($88F0);
private static _R11F_G11F_B10F := new InternalFormat($8C3A);
private static _R11F_G11F_B10F_APPLE := new InternalFormat($8C3A);
private static _R11F_G11F_B10F_EXT := new InternalFormat($8C3A);
private static _RGB9_E5 := new InternalFormat($8C3D);
private static _RGB9_E5_APPLE := new InternalFormat($8C3D);
private static _RGB9_E5_EXT := new InternalFormat($8C3D);
private static _SRGB := new InternalFormat($8C40);
private static _SRGB_EXT := new InternalFormat($8C40);
private static _SRGB8 := new InternalFormat($8C41);
private static _SRGB8_EXT := new InternalFormat($8C41);
private static _SRGB8_NV := new InternalFormat($8C41);
private static _SRGB_ALPHA := new InternalFormat($8C42);
private static _SRGB_ALPHA_EXT := new InternalFormat($8C42);
private static _SRGB8_ALPHA8 := new InternalFormat($8C43);
private static _SRGB8_ALPHA8_EXT := new InternalFormat($8C43);
private static _COMPRESSED_SRGB := new InternalFormat($8C48);
private static _COMPRESSED_SRGB_ALPHA := new InternalFormat($8C49);
private static _COMPRESSED_SRGB_S3TC_DXT1_EXT := new InternalFormat($8C4C);
private static _COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT := new InternalFormat($8C4D);
private static _COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT := new InternalFormat($8C4E);
private static _COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT := new InternalFormat($8C4F);
private static _DEPTH_COMPONENT32F := new InternalFormat($8CAC);
private static _DEPTH32F_STENCIL8 := new InternalFormat($8CAD);
private static _STENCIL_INDEX1 := new InternalFormat($8D46);
private static _STENCIL_INDEX1_EXT := new InternalFormat($8D46);
private static _STENCIL_INDEX1_OES := new InternalFormat($8D46);
private static _STENCIL_INDEX4 := new InternalFormat($8D47);
private static _STENCIL_INDEX4_EXT := new InternalFormat($8D47);
private static _STENCIL_INDEX4_OES := new InternalFormat($8D47);
private static _STENCIL_INDEX8 := new InternalFormat($8D48);
private static _STENCIL_INDEX8_EXT := new InternalFormat($8D48);
private static _STENCIL_INDEX8_OES := new InternalFormat($8D48);
private static _STENCIL_INDEX16 := new InternalFormat($8D49);
private static _STENCIL_INDEX16_EXT := new InternalFormat($8D49);
private static _RGBA32UI := new InternalFormat($8D70);
private static _RGB32UI := new InternalFormat($8D71);
private static _RGBA16UI := new InternalFormat($8D76);
private static _RGB16UI := new InternalFormat($8D77);
private static _RGBA8UI := new InternalFormat($8D7C);
private static _RGB8UI := new InternalFormat($8D7D);
private static _RGBA32I := new InternalFormat($8D82);
private static _RGB32I := new InternalFormat($8D83);
private static _RGBA16I := new InternalFormat($8D88);
private static _RGB16I := new InternalFormat($8D89);
private static _RGBA8I := new InternalFormat($8D8E);
private static _RGB8I := new InternalFormat($8D8F);
private static _DEPTH_COMPONENT32F_NV := new InternalFormat($8DAB);
private static _DEPTH32F_STENCIL8_NV := new InternalFormat($8DAC);
private static _COMPRESSED_RED_RGTC1 := new InternalFormat($8DBB);
private static _COMPRESSED_RED_RGTC1_EXT := new InternalFormat($8DBB);
private static _COMPRESSED_SIGNED_RED_RGTC1 := new InternalFormat($8DBC);
private static _COMPRESSED_SIGNED_RED_RGTC1_EXT := new InternalFormat($8DBC);
private static _COMPRESSED_RG_RGTC2 := new InternalFormat($8DBD);
private static _COMPRESSED_SIGNED_RG_RGTC2 := new InternalFormat($8DBE);
private static _COMPRESSED_RGBA_BPTC_UNORM := new InternalFormat($8E8C);
private static _COMPRESSED_SRGB_ALPHA_BPTC_UNORM := new InternalFormat($8E8D);
private static _COMPRESSED_RGB_BPTC_SIGNED_FLOAT := new InternalFormat($8E8E);
private static _COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT := new InternalFormat($8E8F);
private static _R8_SNORM := new InternalFormat($8F94);
private static _RG8_SNORM := new InternalFormat($8F95);
private static _RGB8_SNORM := new InternalFormat($8F96);
private static _RGBA8_SNORM := new InternalFormat($8F97);
private static _R16_SNORM := new InternalFormat($8F98);
private static _R16_SNORM_EXT := new InternalFormat($8F98);
private static _RG16_SNORM := new InternalFormat($8F99);
private static _RG16_SNORM_EXT := new InternalFormat($8F99);
private static _RGB16_SNORM := new InternalFormat($8F9A);
private static _RGB16_SNORM_EXT := new InternalFormat($8F9A);
private static _RGB10_A2UI := new InternalFormat($906F);
private static _COMPRESSED_R11_EAC := new InternalFormat($9270);
private static _COMPRESSED_SIGNED_R11_EAC := new InternalFormat($9271);
private static _COMPRESSED_RG11_EAC := new InternalFormat($9272);
private static _COMPRESSED_SIGNED_RG11_EAC := new InternalFormat($9273);
private static _COMPRESSED_RGB8_ETC2 := new InternalFormat($9274);
private static _COMPRESSED_SRGB8_ETC2 := new InternalFormat($9275);
private static _COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 := new InternalFormat($9276);
private static _COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 := new InternalFormat($9277);
private static _COMPRESSED_RGBA8_ETC2_EAC := new InternalFormat($9278);
private static _COMPRESSED_SRGB8_ALPHA8_ETC2_EAC := new InternalFormat($9279);
private static _COMPRESSED_RGBA_ASTC_4x4 := new InternalFormat($93B0);
private static _COMPRESSED_RGBA_ASTC_4x4_KHR := new InternalFormat($93B0);
private static _COMPRESSED_RGBA_ASTC_5x4 := new InternalFormat($93B1);
private static _COMPRESSED_RGBA_ASTC_5x4_KHR := new InternalFormat($93B1);
private static _COMPRESSED_RGBA_ASTC_5x5 := new InternalFormat($93B2);
private static _COMPRESSED_RGBA_ASTC_5x5_KHR := new InternalFormat($93B2);
private static _COMPRESSED_RGBA_ASTC_6x5 := new InternalFormat($93B3);
private static _COMPRESSED_RGBA_ASTC_6x5_KHR := new InternalFormat($93B3);
private static _COMPRESSED_RGBA_ASTC_6x6 := new InternalFormat($93B4);
private static _COMPRESSED_RGBA_ASTC_6x6_KHR := new InternalFormat($93B4);
private static _COMPRESSED_RGBA_ASTC_8x5 := new InternalFormat($93B5);
private static _COMPRESSED_RGBA_ASTC_8x5_KHR := new InternalFormat($93B5);
private static _COMPRESSED_RGBA_ASTC_8x6 := new InternalFormat($93B6);
private static _COMPRESSED_RGBA_ASTC_8x6_KHR := new InternalFormat($93B6);
private static _COMPRESSED_RGBA_ASTC_8x8 := new InternalFormat($93B7);
private static _COMPRESSED_RGBA_ASTC_8x8_KHR := new InternalFormat($93B7);
private static _COMPRESSED_RGBA_ASTC_10x5 := new InternalFormat($93B8);
private static _COMPRESSED_RGBA_ASTC_10x5_KHR := new InternalFormat($93B8);
private static _COMPRESSED_RGBA_ASTC_10x6 := new InternalFormat($93B9);
private static _COMPRESSED_RGBA_ASTC_10x6_KHR := new InternalFormat($93B9);
private static _COMPRESSED_RGBA_ASTC_10x8 := new InternalFormat($93BA);
private static _COMPRESSED_RGBA_ASTC_10x8_KHR := new InternalFormat($93BA);
private static _COMPRESSED_RGBA_ASTC_10x10 := new InternalFormat($93BB);
private static _COMPRESSED_RGBA_ASTC_10x10_KHR := new InternalFormat($93BB);
private static _COMPRESSED_RGBA_ASTC_12x10 := new InternalFormat($93BC);
private static _COMPRESSED_RGBA_ASTC_12x10_KHR := new InternalFormat($93BC);
private static _COMPRESSED_RGBA_ASTC_12x12 := new InternalFormat($93BD);
private static _COMPRESSED_RGBA_ASTC_12x12_KHR := new InternalFormat($93BD);
private static _COMPRESSED_RGBA_ASTC_3x3x3_OES := new InternalFormat($93C0);
private static _COMPRESSED_RGBA_ASTC_4x3x3_OES := new InternalFormat($93C1);
private static _COMPRESSED_RGBA_ASTC_4x4x3_OES := new InternalFormat($93C2);
private static _COMPRESSED_RGBA_ASTC_4x4x4_OES := new InternalFormat($93C3);
private static _COMPRESSED_RGBA_ASTC_5x4x4_OES := new InternalFormat($93C4);
private static _COMPRESSED_RGBA_ASTC_5x5x4_OES := new InternalFormat($93C5);
private static _COMPRESSED_RGBA_ASTC_5x5x5_OES := new InternalFormat($93C6);
private static _COMPRESSED_RGBA_ASTC_6x5x5_OES := new InternalFormat($93C7);
private static _COMPRESSED_RGBA_ASTC_6x6x5_OES := new InternalFormat($93C8);
private static _COMPRESSED_RGBA_ASTC_6x6x6_OES := new InternalFormat($93C9);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4 := new InternalFormat($93D0);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR := new InternalFormat($93D0);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4 := new InternalFormat($93D1);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR := new InternalFormat($93D1);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5 := new InternalFormat($93D2);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR := new InternalFormat($93D2);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5 := new InternalFormat($93D3);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR := new InternalFormat($93D3);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6 := new InternalFormat($93D4);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR := new InternalFormat($93D4);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x5 := new InternalFormat($93D5);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR := new InternalFormat($93D5);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x6 := new InternalFormat($93D6);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR := new InternalFormat($93D6);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x8 := new InternalFormat($93D7);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR := new InternalFormat($93D7);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x5 := new InternalFormat($93D8);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR := new InternalFormat($93D8);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x6 := new InternalFormat($93D9);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR := new InternalFormat($93D9);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x8 := new InternalFormat($93DA);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR := new InternalFormat($93DA);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x10 := new InternalFormat($93DB);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR := new InternalFormat($93DB);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_12x10 := new InternalFormat($93DC);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR := new InternalFormat($93DC);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_12x12 := new InternalFormat($93DD);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR := new InternalFormat($93DD);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES := new InternalFormat($93E0);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES := new InternalFormat($93E1);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES := new InternalFormat($93E2);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES := new InternalFormat($93E3);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES := new InternalFormat($93E4);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES := new InternalFormat($93E5);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES := new InternalFormat($93E6);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES := new InternalFormat($93E7);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES := new InternalFormat($93E8);
private static _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES := new InternalFormat($93E9);
public static property STENCIL_INDEX: InternalFormat read _STENCIL_INDEX;
public static property STENCIL_INDEX_OES: InternalFormat read _STENCIL_INDEX_OES;
public static property DEPTH_COMPONENT: InternalFormat read _DEPTH_COMPONENT;
public static property RED: InternalFormat read _RED;
public static property RED_EXT: InternalFormat read _RED_EXT;
public static property RGB: InternalFormat read _RGB;
public static property RGBA: InternalFormat read _RGBA;
public static property R3_G3_B2: InternalFormat read _R3_G3_B2;
public static property ALPHA4: InternalFormat read _ALPHA4;
public static property ALPHA8: InternalFormat read _ALPHA8;
public static property ALPHA12: InternalFormat read _ALPHA12;
public static property ALPHA16: InternalFormat read _ALPHA16;
public static property LUMINANCE4: InternalFormat read _LUMINANCE4;
public static property LUMINANCE8: InternalFormat read _LUMINANCE8;
public static property LUMINANCE12: InternalFormat read _LUMINANCE12;
public static property LUMINANCE16: InternalFormat read _LUMINANCE16;
public static property LUMINANCE4_ALPHA4: InternalFormat read _LUMINANCE4_ALPHA4;
public static property LUMINANCE6_ALPHA2: InternalFormat read _LUMINANCE6_ALPHA2;
public static property LUMINANCE8_ALPHA8: InternalFormat read _LUMINANCE8_ALPHA8;
public static property LUMINANCE12_ALPHA4: InternalFormat read _LUMINANCE12_ALPHA4;
public static property LUMINANCE12_ALPHA12: InternalFormat read _LUMINANCE12_ALPHA12;
public static property LUMINANCE16_ALPHA16: InternalFormat read _LUMINANCE16_ALPHA16;
public static property INTENSITY: InternalFormat read _INTENSITY;
public static property INTENSITY4: InternalFormat read _INTENSITY4;
public static property INTENSITY8: InternalFormat read _INTENSITY8;
public static property INTENSITY12: InternalFormat read _INTENSITY12;
public static property INTENSITY16: InternalFormat read _INTENSITY16;
public static property RGB2_EXT: InternalFormat read _RGB2_EXT;
public static property RGB4: InternalFormat read _RGB4;
public static property RGB4_EXT: InternalFormat read _RGB4_EXT;
public static property RGB5: InternalFormat read _RGB5;
public static property RGB5_EXT: InternalFormat read _RGB5_EXT;
public static property RGB8: InternalFormat read _RGB8;
public static property RGB8_EXT: InternalFormat read _RGB8_EXT;
public static property RGB8_OES: InternalFormat read _RGB8_OES;
public static property RGB10: InternalFormat read _RGB10;
public static property RGB10_EXT: InternalFormat read _RGB10_EXT;
public static property RGB12: InternalFormat read _RGB12;
public static property RGB12_EXT: InternalFormat read _RGB12_EXT;
public static property RGB16: InternalFormat read _RGB16;
public static property RGB16_EXT: InternalFormat read _RGB16_EXT;
public static property RGBA4: InternalFormat read _RGBA4;
public static property RGBA4_EXT: InternalFormat read _RGBA4_EXT;
public static property RGBA4_OES: InternalFormat read _RGBA4_OES;
public static property RGB5_A1: InternalFormat read _RGB5_A1;
public static property RGB5_A1_EXT: InternalFormat read _RGB5_A1_EXT;
public static property RGB5_A1_OES: InternalFormat read _RGB5_A1_OES;
public static property RGBA8: InternalFormat read _RGBA8;
public static property RGBA8_EXT: InternalFormat read _RGBA8_EXT;
public static property RGBA8_OES: InternalFormat read _RGBA8_OES;
public static property RGB10_A2: InternalFormat read _RGB10_A2;
public static property RGB10_A2_EXT: InternalFormat read _RGB10_A2_EXT;
public static property RGBA12: InternalFormat read _RGBA12;
public static property RGBA12_EXT: InternalFormat read _RGBA12_EXT;
public static property RGBA16: InternalFormat read _RGBA16;
public static property RGBA16_EXT: InternalFormat read _RGBA16_EXT;
public static property DUAL_ALPHA4_SGIS: InternalFormat read _DUAL_ALPHA4_SGIS;
public static property DUAL_ALPHA8_SGIS: InternalFormat read _DUAL_ALPHA8_SGIS;
public static property DUAL_ALPHA12_SGIS: InternalFormat read _DUAL_ALPHA12_SGIS;
public static property DUAL_ALPHA16_SGIS: InternalFormat read _DUAL_ALPHA16_SGIS;
public static property DUAL_LUMINANCE4_SGIS: InternalFormat read _DUAL_LUMINANCE4_SGIS;
public static property DUAL_LUMINANCE8_SGIS: InternalFormat read _DUAL_LUMINANCE8_SGIS;
public static property DUAL_LUMINANCE12_SGIS: InternalFormat read _DUAL_LUMINANCE12_SGIS;
public static property DUAL_LUMINANCE16_SGIS: InternalFormat read _DUAL_LUMINANCE16_SGIS;
public static property DUAL_INTENSITY4_SGIS: InternalFormat read _DUAL_INTENSITY4_SGIS;
public static property DUAL_INTENSITY8_SGIS: InternalFormat read _DUAL_INTENSITY8_SGIS;
public static property DUAL_INTENSITY12_SGIS: InternalFormat read _DUAL_INTENSITY12_SGIS;
public static property DUAL_INTENSITY16_SGIS: InternalFormat read _DUAL_INTENSITY16_SGIS;
public static property DUAL_LUMINANCE_ALPHA4_SGIS: InternalFormat read _DUAL_LUMINANCE_ALPHA4_SGIS;
public static property DUAL_LUMINANCE_ALPHA8_SGIS: InternalFormat read _DUAL_LUMINANCE_ALPHA8_SGIS;
public static property QUAD_ALPHA4_SGIS: InternalFormat read _QUAD_ALPHA4_SGIS;
public static property QUAD_ALPHA8_SGIS: InternalFormat read _QUAD_ALPHA8_SGIS;
public static property QUAD_LUMINANCE4_SGIS: InternalFormat read _QUAD_LUMINANCE4_SGIS;
public static property QUAD_LUMINANCE8_SGIS: InternalFormat read _QUAD_LUMINANCE8_SGIS;
public static property QUAD_INTENSITY4_SGIS: InternalFormat read _QUAD_INTENSITY4_SGIS;
public static property QUAD_INTENSITY8_SGIS: InternalFormat read _QUAD_INTENSITY8_SGIS;
public static property DEPTH_COMPONENT16: InternalFormat read _DEPTH_COMPONENT16;
public static property DEPTH_COMPONENT16_ARB: InternalFormat read _DEPTH_COMPONENT16_ARB;
public static property DEPTH_COMPONENT16_OES: InternalFormat read _DEPTH_COMPONENT16_OES;
public static property DEPTH_COMPONENT16_SGIX: InternalFormat read _DEPTH_COMPONENT16_SGIX;
public static property DEPTH_COMPONENT24_ARB: InternalFormat read _DEPTH_COMPONENT24_ARB;
public static property DEPTH_COMPONENT24_OES: InternalFormat read _DEPTH_COMPONENT24_OES;
public static property DEPTH_COMPONENT24_SGIX: InternalFormat read _DEPTH_COMPONENT24_SGIX;
public static property DEPTH_COMPONENT32_ARB: InternalFormat read _DEPTH_COMPONENT32_ARB;
public static property DEPTH_COMPONENT32_OES: InternalFormat read _DEPTH_COMPONENT32_OES;
public static property DEPTH_COMPONENT32_SGIX: InternalFormat read _DEPTH_COMPONENT32_SGIX;
public static property COMPRESSED_RED: InternalFormat read _COMPRESSED_RED;
public static property COMPRESSED_RG: InternalFormat read _COMPRESSED_RG;
public static property RG: InternalFormat read _RG;
public static property R8: InternalFormat read _R8;
public static property R8_EXT: InternalFormat read _R8_EXT;
public static property R16: InternalFormat read _R16;
public static property R16_EXT: InternalFormat read _R16_EXT;
public static property RG8: InternalFormat read _RG8;
public static property RG8_EXT: InternalFormat read _RG8_EXT;
public static property RG16: InternalFormat read _RG16;
public static property RG16_EXT: InternalFormat read _RG16_EXT;
public static property R16F: InternalFormat read _R16F;
public static property R16F_EXT: InternalFormat read _R16F_EXT;
public static property R32F: InternalFormat read _R32F;
public static property R32F_EXT: InternalFormat read _R32F_EXT;
public static property RG16F: InternalFormat read _RG16F;
public static property RG16F_EXT: InternalFormat read _RG16F_EXT;
public static property RG32F: InternalFormat read _RG32F;
public static property RG32F_EXT: InternalFormat read _RG32F_EXT;
public static property R8I: InternalFormat read _R8I;
public static property R8UI: InternalFormat read _R8UI;
public static property R16I: InternalFormat read _R16I;
public static property R16UI: InternalFormat read _R16UI;
public static property R32I: InternalFormat read _R32I;
public static property R32UI: InternalFormat read _R32UI;
public static property RG8I: InternalFormat read _RG8I;
public static property RG8UI: InternalFormat read _RG8UI;
public static property RG16I: InternalFormat read _RG16I;
public static property RG16UI: InternalFormat read _RG16UI;
public static property RG32I: InternalFormat read _RG32I;
public static property RG32UI: InternalFormat read _RG32UI;
public static property COMPRESSED_RGB_S3TC_DXT1_EXT: InternalFormat read _COMPRESSED_RGB_S3TC_DXT1_EXT;
public static property COMPRESSED_RGBA_S3TC_DXT1_EXT: InternalFormat read _COMPRESSED_RGBA_S3TC_DXT1_EXT;
public static property COMPRESSED_RGBA_S3TC_DXT3_EXT: InternalFormat read _COMPRESSED_RGBA_S3TC_DXT3_EXT;
public static property COMPRESSED_RGBA_S3TC_DXT5_EXT: InternalFormat read _COMPRESSED_RGBA_S3TC_DXT5_EXT;
public static property COMPRESSED_RGB: InternalFormat read _COMPRESSED_RGB;
public static property COMPRESSED_RGBA: InternalFormat read _COMPRESSED_RGBA;
public static property DEPTH_STENCIL: InternalFormat read _DEPTH_STENCIL;
public static property DEPTH_STENCIL_EXT: InternalFormat read _DEPTH_STENCIL_EXT;
public static property DEPTH_STENCIL_NV: InternalFormat read _DEPTH_STENCIL_NV;
public static property DEPTH_STENCIL_OES: InternalFormat read _DEPTH_STENCIL_OES;
public static property DEPTH_STENCIL_MESA: InternalFormat read _DEPTH_STENCIL_MESA;
public static property RGBA32F: InternalFormat read _RGBA32F;
public static property RGBA32F_ARB: InternalFormat read _RGBA32F_ARB;
public static property RGBA32F_EXT: InternalFormat read _RGBA32F_EXT;
public static property RGB32F: InternalFormat read _RGB32F;
public static property RGBA16F: InternalFormat read _RGBA16F;
public static property RGBA16F_ARB: InternalFormat read _RGBA16F_ARB;
public static property RGBA16F_EXT: InternalFormat read _RGBA16F_EXT;
public static property RGB16F: InternalFormat read _RGB16F;
public static property RGB16F_ARB: InternalFormat read _RGB16F_ARB;
public static property RGB16F_EXT: InternalFormat read _RGB16F_EXT;
public static property DEPTH24_STENCIL8: InternalFormat read _DEPTH24_STENCIL8;
public static property DEPTH24_STENCIL8_EXT: InternalFormat read _DEPTH24_STENCIL8_EXT;
public static property DEPTH24_STENCIL8_OES: InternalFormat read _DEPTH24_STENCIL8_OES;
public static property R11F_G11F_B10F: InternalFormat read _R11F_G11F_B10F;
public static property R11F_G11F_B10F_APPLE: InternalFormat read _R11F_G11F_B10F_APPLE;
public static property R11F_G11F_B10F_EXT: InternalFormat read _R11F_G11F_B10F_EXT;
public static property RGB9_E5: InternalFormat read _RGB9_E5;
public static property RGB9_E5_APPLE: InternalFormat read _RGB9_E5_APPLE;
public static property RGB9_E5_EXT: InternalFormat read _RGB9_E5_EXT;
public static property SRGB: InternalFormat read _SRGB;
public static property SRGB_EXT: InternalFormat read _SRGB_EXT;
public static property SRGB8: InternalFormat read _SRGB8;
public static property SRGB8_EXT: InternalFormat read _SRGB8_EXT;
public static property SRGB8_NV: InternalFormat read _SRGB8_NV;
public static property SRGB_ALPHA: InternalFormat read _SRGB_ALPHA;
public static property SRGB_ALPHA_EXT: InternalFormat read _SRGB_ALPHA_EXT;
public static property SRGB8_ALPHA8: InternalFormat read _SRGB8_ALPHA8;
public static property SRGB8_ALPHA8_EXT: InternalFormat read _SRGB8_ALPHA8_EXT;
public static property COMPRESSED_SRGB: InternalFormat read _COMPRESSED_SRGB;
public static property COMPRESSED_SRGB_ALPHA: InternalFormat read _COMPRESSED_SRGB_ALPHA;
public static property COMPRESSED_SRGB_S3TC_DXT1_EXT: InternalFormat read _COMPRESSED_SRGB_S3TC_DXT1_EXT;
public static property COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: InternalFormat read _COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
public static property COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: InternalFormat read _COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
public static property COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: InternalFormat read _COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
public static property DEPTH_COMPONENT32F: InternalFormat read _DEPTH_COMPONENT32F;
public static property DEPTH32F_STENCIL8: InternalFormat read _DEPTH32F_STENCIL8;
public static property STENCIL_INDEX1: InternalFormat read _STENCIL_INDEX1;
public static property STENCIL_INDEX1_EXT: InternalFormat read _STENCIL_INDEX1_EXT;
public static property STENCIL_INDEX1_OES: InternalFormat read _STENCIL_INDEX1_OES;
public static property STENCIL_INDEX4: InternalFormat read _STENCIL_INDEX4;
public static property STENCIL_INDEX4_EXT: InternalFormat read _STENCIL_INDEX4_EXT;
public static property STENCIL_INDEX4_OES: InternalFormat read _STENCIL_INDEX4_OES;
public static property STENCIL_INDEX8: InternalFormat read _STENCIL_INDEX8;
public static property STENCIL_INDEX8_EXT: InternalFormat read _STENCIL_INDEX8_EXT;
public static property STENCIL_INDEX8_OES: InternalFormat read _STENCIL_INDEX8_OES;
public static property STENCIL_INDEX16: InternalFormat read _STENCIL_INDEX16;
public static property STENCIL_INDEX16_EXT: InternalFormat read _STENCIL_INDEX16_EXT;
public static property RGBA32UI: InternalFormat read _RGBA32UI;
public static property RGB32UI: InternalFormat read _RGB32UI;
public static property RGBA16UI: InternalFormat read _RGBA16UI;
public static property RGB16UI: InternalFormat read _RGB16UI;
public static property RGBA8UI: InternalFormat read _RGBA8UI;
public static property RGB8UI: InternalFormat read _RGB8UI;
public static property RGBA32I: InternalFormat read _RGBA32I;
public static property RGB32I: InternalFormat read _RGB32I;
public static property RGBA16I: InternalFormat read _RGBA16I;
public static property RGB16I: InternalFormat read _RGB16I;
public static property RGBA8I: InternalFormat read _RGBA8I;
public static property RGB8I: InternalFormat read _RGB8I;
public static property DEPTH_COMPONENT32F_NV: InternalFormat read _DEPTH_COMPONENT32F_NV;
public static property DEPTH32F_STENCIL8_NV: InternalFormat read _DEPTH32F_STENCIL8_NV;
public static property COMPRESSED_RED_RGTC1: InternalFormat read _COMPRESSED_RED_RGTC1;
public static property COMPRESSED_RED_RGTC1_EXT: InternalFormat read _COMPRESSED_RED_RGTC1_EXT;
public static property COMPRESSED_SIGNED_RED_RGTC1: InternalFormat read _COMPRESSED_SIGNED_RED_RGTC1;
public static property COMPRESSED_SIGNED_RED_RGTC1_EXT: InternalFormat read _COMPRESSED_SIGNED_RED_RGTC1_EXT;
public static property COMPRESSED_RG_RGTC2: InternalFormat read _COMPRESSED_RG_RGTC2;
public static property COMPRESSED_SIGNED_RG_RGTC2: InternalFormat read _COMPRESSED_SIGNED_RG_RGTC2;
public static property COMPRESSED_RGBA_BPTC_UNORM: InternalFormat read _COMPRESSED_RGBA_BPTC_UNORM;
public static property COMPRESSED_SRGB_ALPHA_BPTC_UNORM: InternalFormat read _COMPRESSED_SRGB_ALPHA_BPTC_UNORM;
public static property COMPRESSED_RGB_BPTC_SIGNED_FLOAT: InternalFormat read _COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
public static property COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: InternalFormat read _COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
public static property R8_SNORM: InternalFormat read _R8_SNORM;
public static property RG8_SNORM: InternalFormat read _RG8_SNORM;
public static property RGB8_SNORM: InternalFormat read _RGB8_SNORM;
public static property RGBA8_SNORM: InternalFormat read _RGBA8_SNORM;
public static property R16_SNORM: InternalFormat read _R16_SNORM;
public static property R16_SNORM_EXT: InternalFormat read _R16_SNORM_EXT;
public static property RG16_SNORM: InternalFormat read _RG16_SNORM;
public static property RG16_SNORM_EXT: InternalFormat read _RG16_SNORM_EXT;
public static property RGB16_SNORM: InternalFormat read _RGB16_SNORM;
public static property RGB16_SNORM_EXT: InternalFormat read _RGB16_SNORM_EXT;
public static property RGB10_A2UI: InternalFormat read _RGB10_A2UI;
public static property COMPRESSED_R11_EAC: InternalFormat read _COMPRESSED_R11_EAC;
public static property COMPRESSED_SIGNED_R11_EAC: InternalFormat read _COMPRESSED_SIGNED_R11_EAC;
public static property COMPRESSED_RG11_EAC: InternalFormat read _COMPRESSED_RG11_EAC;
public static property COMPRESSED_SIGNED_RG11_EAC: InternalFormat read _COMPRESSED_SIGNED_RG11_EAC;
public static property COMPRESSED_RGB8_ETC2: InternalFormat read _COMPRESSED_RGB8_ETC2;
public static property COMPRESSED_SRGB8_ETC2: InternalFormat read _COMPRESSED_SRGB8_ETC2;
public static property COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: InternalFormat read _COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
public static property COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: InternalFormat read _COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
public static property COMPRESSED_RGBA8_ETC2_EAC: InternalFormat read _COMPRESSED_RGBA8_ETC2_EAC;
public static property COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
public static property COMPRESSED_RGBA_ASTC_4x4: InternalFormat read _COMPRESSED_RGBA_ASTC_4x4;
public static property COMPRESSED_RGBA_ASTC_4x4_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_4x4_KHR;
public static property COMPRESSED_RGBA_ASTC_5x4: InternalFormat read _COMPRESSED_RGBA_ASTC_5x4;
public static property COMPRESSED_RGBA_ASTC_5x4_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_5x4_KHR;
public static property COMPRESSED_RGBA_ASTC_5x5: InternalFormat read _COMPRESSED_RGBA_ASTC_5x5;
public static property COMPRESSED_RGBA_ASTC_5x5_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_5x5_KHR;
public static property COMPRESSED_RGBA_ASTC_6x5: InternalFormat read _COMPRESSED_RGBA_ASTC_6x5;
public static property COMPRESSED_RGBA_ASTC_6x5_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_6x5_KHR;
public static property COMPRESSED_RGBA_ASTC_6x6: InternalFormat read _COMPRESSED_RGBA_ASTC_6x6;
public static property COMPRESSED_RGBA_ASTC_6x6_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_6x6_KHR;
public static property COMPRESSED_RGBA_ASTC_8x5: InternalFormat read _COMPRESSED_RGBA_ASTC_8x5;
public static property COMPRESSED_RGBA_ASTC_8x5_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_8x5_KHR;
public static property COMPRESSED_RGBA_ASTC_8x6: InternalFormat read _COMPRESSED_RGBA_ASTC_8x6;
public static property COMPRESSED_RGBA_ASTC_8x6_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_8x6_KHR;
public static property COMPRESSED_RGBA_ASTC_8x8: InternalFormat read _COMPRESSED_RGBA_ASTC_8x8;
public static property COMPRESSED_RGBA_ASTC_8x8_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_8x8_KHR;
public static property COMPRESSED_RGBA_ASTC_10x5: InternalFormat read _COMPRESSED_RGBA_ASTC_10x5;
public static property COMPRESSED_RGBA_ASTC_10x5_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_10x5_KHR;
public static property COMPRESSED_RGBA_ASTC_10x6: InternalFormat read _COMPRESSED_RGBA_ASTC_10x6;
public static property COMPRESSED_RGBA_ASTC_10x6_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_10x6_KHR;
public static property COMPRESSED_RGBA_ASTC_10x8: InternalFormat read _COMPRESSED_RGBA_ASTC_10x8;
public static property COMPRESSED_RGBA_ASTC_10x8_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_10x8_KHR;
public static property COMPRESSED_RGBA_ASTC_10x10: InternalFormat read _COMPRESSED_RGBA_ASTC_10x10;
public static property COMPRESSED_RGBA_ASTC_10x10_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_10x10_KHR;
public static property COMPRESSED_RGBA_ASTC_12x10: InternalFormat read _COMPRESSED_RGBA_ASTC_12x10;
public static property COMPRESSED_RGBA_ASTC_12x10_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_12x10_KHR;
public static property COMPRESSED_RGBA_ASTC_12x12: InternalFormat read _COMPRESSED_RGBA_ASTC_12x12;
public static property COMPRESSED_RGBA_ASTC_12x12_KHR: InternalFormat read _COMPRESSED_RGBA_ASTC_12x12_KHR;
public static property COMPRESSED_RGBA_ASTC_3x3x3_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_3x3x3_OES;
public static property COMPRESSED_RGBA_ASTC_4x3x3_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_4x3x3_OES;
public static property COMPRESSED_RGBA_ASTC_4x4x3_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_4x4x3_OES;
public static property COMPRESSED_RGBA_ASTC_4x4x4_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_4x4x4_OES;
public static property COMPRESSED_RGBA_ASTC_5x4x4_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_5x4x4_OES;
public static property COMPRESSED_RGBA_ASTC_5x5x4_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_5x5x4_OES;
public static property COMPRESSED_RGBA_ASTC_5x5x5_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_5x5x5_OES;
public static property COMPRESSED_RGBA_ASTC_6x5x5_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_6x5x5_OES;
public static property COMPRESSED_RGBA_ASTC_6x6x5_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_6x6x5_OES;
public static property COMPRESSED_RGBA_ASTC_6x6x6_OES: InternalFormat read _COMPRESSED_RGBA_ASTC_6x6x6_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_4x4: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x4: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x5: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x5: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x6: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x5: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x5;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x6: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x6;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x8: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x8;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x5: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x5;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x6: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x6;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x8: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x8;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x10: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x10;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_12x10: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_12x10;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_12x12: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_12x12;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES;
public static property COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES: InternalFormat read _COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES;
public function ToString: string; override;
begin
if self.val = UInt32($1901) then Result := 'STENCIL_INDEX' else
if self.val = UInt32($1901) then Result := 'STENCIL_INDEX_OES' else
if self.val = UInt32($1902) then Result := 'DEPTH_COMPONENT' else
if self.val = UInt32($1903) then Result := 'RED' else
if self.val = UInt32($1903) then Result := 'RED_EXT' else
if self.val = UInt32($1907) then Result := 'RGB' else
if self.val = UInt32($1908) then Result := 'RGBA' else
if self.val = UInt32($2A10) then Result := 'R3_G3_B2' else
if self.val = UInt32($803B) then Result := 'ALPHA4' else
if self.val = UInt32($803C) then Result := 'ALPHA8' else
if self.val = UInt32($803D) then Result := 'ALPHA12' else
if self.val = UInt32($803E) then Result := 'ALPHA16' else
if self.val = UInt32($803F) then Result := 'LUMINANCE4' else
if self.val = UInt32($8040) then Result := 'LUMINANCE8' else
if self.val = UInt32($8041) then Result := 'LUMINANCE12' else
if self.val = UInt32($8042) then Result := 'LUMINANCE16' else
if self.val = UInt32($8043) then Result := 'LUMINANCE4_ALPHA4' else
if self.val = UInt32($8044) then Result := 'LUMINANCE6_ALPHA2' else
if self.val = UInt32($8045) then Result := 'LUMINANCE8_ALPHA8' else
if self.val = UInt32($8046) then Result := 'LUMINANCE12_ALPHA4' else
if self.val = UInt32($8047) then Result := 'LUMINANCE12_ALPHA12' else
if self.val = UInt32($8048) then Result := 'LUMINANCE16_ALPHA16' else
if self.val = UInt32($8049) then Result := 'INTENSITY' else
if self.val = UInt32($804A) then Result := 'INTENSITY4' else
if self.val = UInt32($804B) then Result := 'INTENSITY8' else
if self.val = UInt32($804C) then Result := 'INTENSITY12' else
if self.val = UInt32($804D) then Result := 'INTENSITY16' else
if self.val = UInt32($804E) then Result := 'RGB2_EXT' else
if self.val = UInt32($804F) then Result := 'RGB4' else
if self.val = UInt32($804F) then Result := 'RGB4_EXT' else
if self.val = UInt32($8050) then Result := 'RGB5' else
if self.val = UInt32($8050) then Result := 'RGB5_EXT' else
if self.val = UInt32($8051) then Result := 'RGB8' else
if self.val = UInt32($8051) then Result := 'RGB8_EXT' else
if self.val = UInt32($8051) then Result := 'RGB8_OES' else
if self.val = UInt32($8052) then Result := 'RGB10' else
if self.val = UInt32($8052) then Result := 'RGB10_EXT' else
if self.val = UInt32($8053) then Result := 'RGB12' else
if self.val = UInt32($8053) then Result := 'RGB12_EXT' else
if self.val = UInt32($8054) then Result := 'RGB16' else
if self.val = UInt32($8054) then Result := 'RGB16_EXT' else
if self.val = UInt32($8056) then Result := 'RGBA4' else
if self.val = UInt32($8056) then Result := 'RGBA4_EXT' else
if self.val = UInt32($8056) then Result := 'RGBA4_OES' else
if self.val = UInt32($8057) then Result := 'RGB5_A1' else
if self.val = UInt32($8057) then Result := 'RGB5_A1_EXT' else
if self.val = UInt32($8057) then Result := 'RGB5_A1_OES' else
if self.val = UInt32($8058) then Result := 'RGBA8' else
if self.val = UInt32($8058) then Result := 'RGBA8_EXT' else
if self.val = UInt32($8058) then Result := 'RGBA8_OES' else
if self.val = UInt32($8059) then Result := 'RGB10_A2' else
if self.val = UInt32($8059) then Result := 'RGB10_A2_EXT' else
if self.val = UInt32($805A) then Result := 'RGBA12' else
if self.val = UInt32($805A) then Result := 'RGBA12_EXT' else
if self.val = UInt32($805B) then Result := 'RGBA16' else
if self.val = UInt32($805B) then Result := 'RGBA16_EXT' else
if self.val = UInt32($8110) then Result := 'DUAL_ALPHA4_SGIS' else
if self.val = UInt32($8111) then Result := 'DUAL_ALPHA8_SGIS' else
if self.val = UInt32($8112) then Result := 'DUAL_ALPHA12_SGIS' else
if self.val = UInt32($8113) then Result := 'DUAL_ALPHA16_SGIS' else
if self.val = UInt32($8114) then Result := 'DUAL_LUMINANCE4_SGIS' else
if self.val = UInt32($8115) then Result := 'DUAL_LUMINANCE8_SGIS' else
if self.val = UInt32($8116) then Result := 'DUAL_LUMINANCE12_SGIS' else
if self.val = UInt32($8117) then Result := 'DUAL_LUMINANCE16_SGIS' else
if self.val = UInt32($8118) then Result := 'DUAL_INTENSITY4_SGIS' else
if self.val = UInt32($8119) then Result := 'DUAL_INTENSITY8_SGIS' else
if self.val = UInt32($811A) then Result := 'DUAL_INTENSITY12_SGIS' else
if self.val = UInt32($811B) then Result := 'DUAL_INTENSITY16_SGIS' else
if self.val = UInt32($811C) then Result := 'DUAL_LUMINANCE_ALPHA4_SGIS' else
if self.val = UInt32($811D) then Result := 'DUAL_LUMINANCE_ALPHA8_SGIS' else
if self.val = UInt32($811E) then Result := 'QUAD_ALPHA4_SGIS' else
if self.val = UInt32($811F) then Result := 'QUAD_ALPHA8_SGIS' else
if self.val = UInt32($8120) then Result := 'QUAD_LUMINANCE4_SGIS' else
if self.val = UInt32($8121) then Result := 'QUAD_LUMINANCE8_SGIS' else
if self.val = UInt32($8122) then Result := 'QUAD_INTENSITY4_SGIS' else
if self.val = UInt32($8123) then Result := 'QUAD_INTENSITY8_SGIS' else
if self.val = UInt32($81A5) then Result := 'DEPTH_COMPONENT16' else
if self.val = UInt32($81A5) then Result := 'DEPTH_COMPONENT16_ARB' else
if self.val = UInt32($81A5) then Result := 'DEPTH_COMPONENT16_OES' else
if self.val = UInt32($81A5) then Result := 'DEPTH_COMPONENT16_SGIX' else
if self.val = UInt32($81A6) then Result := 'DEPTH_COMPONENT24_ARB' else
if self.val = UInt32($81A6) then Result := 'DEPTH_COMPONENT24_OES' else
if self.val = UInt32($81A6) then Result := 'DEPTH_COMPONENT24_SGIX' else
if self.val = UInt32($81A7) then Result := 'DEPTH_COMPONENT32_ARB' else
if self.val = UInt32($81A7) then Result := 'DEPTH_COMPONENT32_OES' else
if self.val = UInt32($81A7) then Result := 'DEPTH_COMPONENT32_SGIX' else
if self.val = UInt32($8225) then Result := 'COMPRESSED_RED' else
if self.val = UInt32($8226) then Result := 'COMPRESSED_RG' else
if self.val = UInt32($8227) then Result := 'RG' else
if self.val = UInt32($8229) then Result := 'R8' else
if self.val = UInt32($8229) then Result := 'R8_EXT' else
if self.val = UInt32($822A) then Result := 'R16' else
if self.val = UInt32($822A) then Result := 'R16_EXT' else
if self.val = UInt32($822B) then Result := 'RG8' else
if self.val = UInt32($822B) then Result := 'RG8_EXT' else
if self.val = UInt32($822C) then Result := 'RG16' else
if self.val = UInt32($822C) then Result := 'RG16_EXT' else
if self.val = UInt32($822D) then Result := 'R16F' else
if self.val = UInt32($822D) then Result := 'R16F_EXT' else
if self.val = UInt32($822E) then Result := 'R32F' else
if self.val = UInt32($822E) then Result := 'R32F_EXT' else
if self.val = UInt32($822F) then Result := 'RG16F' else
if self.val = UInt32($822F) then Result := 'RG16F_EXT' else
if self.val = UInt32($8230) then Result := 'RG32F' else
if self.val = UInt32($8230) then Result := 'RG32F_EXT' else
if self.val = UInt32($8231) then Result := 'R8I' else
if self.val = UInt32($8232) then Result := 'R8UI' else
if self.val = UInt32($8233) then Result := 'R16I' else
if self.val = UInt32($8234) then Result := 'R16UI' else
if self.val = UInt32($8235) then Result := 'R32I' else
if self.val = UInt32($8236) then Result := 'R32UI' else
if self.val = UInt32($8237) then Result := 'RG8I' else
if self.val = UInt32($8238) then Result := 'RG8UI' else
if self.val = UInt32($8239) then Result := 'RG16I' else
if self.val = UInt32($823A) then Result := 'RG16UI' else
if self.val = UInt32($823B) then Result := 'RG32I' else
if self.val = UInt32($823C) then Result := 'RG32UI' else
if self.val = UInt32($83F0) then Result := 'COMPRESSED_RGB_S3TC_DXT1_EXT' else
if self.val = UInt32($83F1) then Result := 'COMPRESSED_RGBA_S3TC_DXT1_EXT' else
if self.val = UInt32($83F2) then Result := 'COMPRESSED_RGBA_S3TC_DXT3_EXT' else
if self.val = UInt32($83F3) then Result := 'COMPRESSED_RGBA_S3TC_DXT5_EXT' else
if self.val = UInt32($84ED) then Result := 'COMPRESSED_RGB' else
if self.val = UInt32($84EE) then Result := 'COMPRESSED_RGBA' else
if self.val = UInt32($84F9) then Result := 'DEPTH_STENCIL' else
if self.val = UInt32($84F9) then Result := 'DEPTH_STENCIL_EXT' else
if self.val = UInt32($84F9) then Result := 'DEPTH_STENCIL_NV' else
if self.val = UInt32($84F9) then Result := 'DEPTH_STENCIL_OES' else
if self.val = UInt32($8750) then Result := 'DEPTH_STENCIL_MESA' else
if self.val = UInt32($8814) then Result := 'RGBA32F' else
if self.val = UInt32($8814) then Result := 'RGBA32F_ARB' else
if self.val = UInt32($8814) then Result := 'RGBA32F_EXT' else
if self.val = UInt32($8815) then Result := 'RGB32F' else
if self.val = UInt32($881A) then Result := 'RGBA16F' else
if self.val = UInt32($881A) then Result := 'RGBA16F_ARB' else
if self.val = UInt32($881A) then Result := 'RGBA16F_EXT' else
if self.val = UInt32($881B) then Result := 'RGB16F' else
if self.val = UInt32($881B) then Result := 'RGB16F_ARB' else
if self.val = UInt32($881B) then Result := 'RGB16F_EXT' else
if self.val = UInt32($88F0) then Result := 'DEPTH24_STENCIL8' else
if self.val = UInt32($88F0) then Result := 'DEPTH24_STENCIL8_EXT' else
if self.val = UInt32($88F0) then Result := 'DEPTH24_STENCIL8_OES' else
if self.val = UInt32($8C3A) then Result := 'R11F_G11F_B10F' else
if self.val = UInt32($8C3A) then Result := 'R11F_G11F_B10F_APPLE' else
if self.val = UInt32($8C3A) then Result := 'R11F_G11F_B10F_EXT' else
if self.val = UInt32($8C3D) then Result := 'RGB9_E5' else
if self.val = UInt32($8C3D) then Result := 'RGB9_E5_APPLE' else
if self.val = UInt32($8C3D) then Result := 'RGB9_E5_EXT' else
if self.val = UInt32($8C40) then Result := 'SRGB' else
if self.val = UInt32($8C40) then Result := 'SRGB_EXT' else
if self.val = UInt32($8C41) then Result := 'SRGB8' else
if self.val = UInt32($8C41) then Result := 'SRGB8_EXT' else
if self.val = UInt32($8C41) then Result := 'SRGB8_NV' else
if self.val = UInt32($8C42) then Result := 'SRGB_ALPHA' else
if self.val = UInt32($8C42) then Result := 'SRGB_ALPHA_EXT' else
if self.val = UInt32($8C43) then Result := 'SRGB8_ALPHA8' else
if self.val = UInt32($8C43) then Result := 'SRGB8_ALPHA8_EXT' else
if self.val = UInt32($8C48) then Result := 'COMPRESSED_SRGB' else
if self.val = UInt32($8C49) then Result := 'COMPRESSED_SRGB_ALPHA' else
if self.val = UInt32($8C4C) then Result := 'COMPRESSED_SRGB_S3TC_DXT1_EXT' else
if self.val = UInt32($8C4D) then Result := 'COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT' else
if self.val = UInt32($8C4E) then Result := 'COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT' else
if self.val = UInt32($8C4F) then Result := 'COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT' else
if self.val = UInt32($8CAC) then Result := 'DEPTH_COMPONENT32F' else
if self.val = UInt32($8CAD) then Result := 'DEPTH32F_STENCIL8' else
if self.val = UInt32($8D46) then Result := 'STENCIL_INDEX1' else
if self.val = UInt32($8D46) then Result := 'STENCIL_INDEX1_EXT' else
if self.val = UInt32($8D46) then Result := 'STENCIL_INDEX1_OES' else
if self.val = UInt32($8D47) then Result := 'STENCIL_INDEX4' else
if self.val = UInt32($8D47) then Result := 'STENCIL_INDEX4_EXT' else
if self.val = UInt32($8D47) then Result := 'STENCIL_INDEX4_OES' else
if self.val = UInt32($8D48) then Result := 'STENCIL_INDEX8' else
if self.val = UInt32($8D48) then Result := 'STENCIL_INDEX8_EXT' else
if self.val = UInt32($8D48) then Result := 'STENCIL_INDEX8_OES' else
if self.val = UInt32($8D49) then Result := 'STENCIL_INDEX16' else
if self.val = UInt32($8D49) then Result := 'STENCIL_INDEX16_EXT' else
if self.val = UInt32($8D70) then Result := 'RGBA32UI' else
if self.val = UInt32($8D71) then Result := 'RGB32UI' else
if self.val = UInt32($8D76) then Result := 'RGBA16UI' else
if self.val = UInt32($8D77) then Result := 'RGB16UI' else
if self.val = UInt32($8D7C) then Result := 'RGBA8UI' else
if self.val = UInt32($8D7D) then Result := 'RGB8UI' else
if self.val = UInt32($8D82) then Result := 'RGBA32I' else
if self.val = UInt32($8D83) then Result := 'RGB32I' else
if self.val = UInt32($8D88) then Result := 'RGBA16I' else
if self.val = UInt32($8D89) then Result := 'RGB16I' else
if self.val = UInt32($8D8E) then Result := 'RGBA8I' else
if self.val = UInt32($8D8F) then Result := 'RGB8I' else
if self.val = UInt32($8DAB) then Result := 'DEPTH_COMPONENT32F_NV' else
if self.val = UInt32($8DAC) then Result := 'DEPTH32F_STENCIL8_NV' else
if self.val = UInt32($8DBB) then Result := 'COMPRESSED_RED_RGTC1' else
if self.val = UInt32($8DBB) then Result := 'COMPRESSED_RED_RGTC1_EXT' else
if self.val = UInt32($8DBC) then Result := 'COMPRESSED_SIGNED_RED_RGTC1' else
if self.val = UInt32($8DBC) then Result := 'COMPRESSED_SIGNED_RED_RGTC1_EXT' else
if self.val = UInt32($8DBD) then Result := 'COMPRESSED_RG_RGTC2' else
if self.val = UInt32($8DBE) then Result := 'COMPRESSED_SIGNED_RG_RGTC2' else
if self.val = UInt32($8E8C) then Result := 'COMPRESSED_RGBA_BPTC_UNORM' else
if self.val = UInt32($8E8D) then Result := 'COMPRESSED_SRGB_ALPHA_BPTC_UNORM' else
if self.val = UInt32($8E8E) then Result := 'COMPRESSED_RGB_BPTC_SIGNED_FLOAT' else
if self.val = UInt32($8E8F) then Result := 'COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT' else
if self.val = UInt32($8F94) then Result := 'R8_SNORM' else
if self.val = UInt32($8F95) then Result := 'RG8_SNORM' else
if self.val = UInt32($8F96) then Result := 'RGB8_SNORM' else
if self.val = UInt32($8F97) then Result := 'RGBA8_SNORM' else
if self.val = UInt32($8F98) then Result := 'R16_SNORM' else
if self.val = UInt32($8F98) then Result := 'R16_SNORM_EXT' else
if self.val = UInt32($8F99) then Result := 'RG16_SNORM' else
if self.val = UInt32($8F99) then Result := 'RG16_SNORM_EXT' else
if self.val = UInt32($8F9A) then Result := 'RGB16_SNORM' else
if self.val = UInt32($8F9A) then Result := 'RGB16_SNORM_EXT' else
if self.val = UInt32($906F) then Result := 'RGB10_A2UI' else
if self.val = UInt32($9270) then Result := 'COMPRESSED_R11_EAC' else
if self.val = UInt32($9271) then Result := 'COMPRESSED_SIGNED_R11_EAC' else
if self.val = UInt32($9272) then Result := 'COMPRESSED_RG11_EAC' else
if self.val = UInt32($9273) then Result := 'COMPRESSED_SIGNED_RG11_EAC' else
if self.val = UInt32($9274) then Result := 'COMPRESSED_RGB8_ETC2' else
if self.val = UInt32($9275) then Result := 'COMPRESSED_SRGB8_ETC2' else
if self.val = UInt32($9276) then Result := 'COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2' else
if self.val = UInt32($9277) then Result := 'COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2' else
if self.val = UInt32($9278) then Result := 'COMPRESSED_RGBA8_ETC2_EAC' else
if self.val = UInt32($9279) then Result := 'COMPRESSED_SRGB8_ALPHA8_ETC2_EAC' else
if self.val = UInt32($93B0) then Result := 'COMPRESSED_RGBA_ASTC_4x4' else
if self.val = UInt32($93B0) then Result := 'COMPRESSED_RGBA_ASTC_4x4_KHR' else
if self.val = UInt32($93B1) then Result := 'COMPRESSED_RGBA_ASTC_5x4' else
if self.val = UInt32($93B1) then Result := 'COMPRESSED_RGBA_ASTC_5x4_KHR' else
if self.val = UInt32($93B2) then Result := 'COMPRESSED_RGBA_ASTC_5x5' else
if self.val = UInt32($93B2) then Result := 'COMPRESSED_RGBA_ASTC_5x5_KHR' else
if self.val = UInt32($93B3) then Result := 'COMPRESSED_RGBA_ASTC_6x5' else
if self.val = UInt32($93B3) then Result := 'COMPRESSED_RGBA_ASTC_6x5_KHR' else
if self.val = UInt32($93B4) then Result := 'COMPRESSED_RGBA_ASTC_6x6' else
if self.val = UInt32($93B4) then Result := 'COMPRESSED_RGBA_ASTC_6x6_KHR' else
if self.val = UInt32($93B5) then Result := 'COMPRESSED_RGBA_ASTC_8x5' else
if self.val = UInt32($93B5) then Result := 'COMPRESSED_RGBA_ASTC_8x5_KHR' else
if self.val = UInt32($93B6) then Result := 'COMPRESSED_RGBA_ASTC_8x6' else
if self.val = UInt32($93B6) then Result := 'COMPRESSED_RGBA_ASTC_8x6_KHR' else
if self.val = UInt32($93B7) then Result := 'COMPRESSED_RGBA_ASTC_8x8' else
if self.val = UInt32($93B7) then Result := 'COMPRESSED_RGBA_ASTC_8x8_KHR' else
if self.val = UInt32($93B8) then Result := 'COMPRESSED_RGBA_ASTC_10x5' else
if self.val = UInt32($93B8) then Result := 'COMPRESSED_RGBA_ASTC_10x5_KHR' else
if self.val = UInt32($93B9) then Result := 'COMPRESSED_RGBA_ASTC_10x6' else
if self.val = UInt32($93B9) then Result := 'COMPRESSED_RGBA_ASTC_10x6_KHR' else
if self.val = UInt32($93BA) then Result := 'COMPRESSED_RGBA_ASTC_10x8' else
if self.val = UInt32($93BA) then Result := 'COMPRESSED_RGBA_ASTC_10x8_KHR' else
if self.val = UInt32($93BB) then Result := 'COMPRESSED_RGBA_ASTC_10x10' else
if self.val = UInt32($93BB) then Result := 'COMPRESSED_RGBA_ASTC_10x10_KHR' else
if self.val = UInt32($93BC) then Result := 'COMPRESSED_RGBA_ASTC_12x10' else
if self.val = UInt32($93BC) then Result := 'COMPRESSED_RGBA_ASTC_12x10_KHR' else
if self.val = UInt32($93BD) then Result := 'COMPRESSED_RGBA_ASTC_12x12' else
if self.val = UInt32($93BD) then Result := 'COMPRESSED_RGBA_ASTC_12x12_KHR' else
if self.val = UInt32($93C0) then Result := 'COMPRESSED_RGBA_ASTC_3x3x3_OES' else
if self.val = UInt32($93C1) then Result := 'COMPRESSED_RGBA_ASTC_4x3x3_OES' else
if self.val = UInt32($93C2) then Result := 'COMPRESSED_RGBA_ASTC_4x4x3_OES' else
if self.val = UInt32($93C3) then Result := 'COMPRESSED_RGBA_ASTC_4x4x4_OES' else
if self.val = UInt32($93C4) then Result := 'COMPRESSED_RGBA_ASTC_5x4x4_OES' else
if self.val = UInt32($93C5) then Result := 'COMPRESSED_RGBA_ASTC_5x5x4_OES' else
if self.val = UInt32($93C6) then Result := 'COMPRESSED_RGBA_ASTC_5x5x5_OES' else
if self.val = UInt32($93C7) then Result := 'COMPRESSED_RGBA_ASTC_6x5x5_OES' else
if self.val = UInt32($93C8) then Result := 'COMPRESSED_RGBA_ASTC_6x6x5_OES' else
if self.val = UInt32($93C9) then Result := 'COMPRESSED_RGBA_ASTC_6x6x6_OES' else
if self.val = UInt32($93D0) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_4x4' else
if self.val = UInt32($93D0) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR' else
if self.val = UInt32($93D1) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x4' else
if self.val = UInt32($93D1) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR' else
if self.val = UInt32($93D2) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x5' else
if self.val = UInt32($93D2) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR' else
if self.val = UInt32($93D3) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x5' else
if self.val = UInt32($93D3) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR' else
if self.val = UInt32($93D4) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x6' else
if self.val = UInt32($93D4) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR' else
if self.val = UInt32($93D5) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x5' else
if self.val = UInt32($93D5) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR' else
if self.val = UInt32($93D6) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x6' else
if self.val = UInt32($93D6) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR' else
if self.val = UInt32($93D7) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x8' else
if self.val = UInt32($93D7) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR' else
if self.val = UInt32($93D8) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x5' else
if self.val = UInt32($93D8) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR' else
if self.val = UInt32($93D9) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x6' else
if self.val = UInt32($93D9) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR' else
if self.val = UInt32($93DA) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x8' else
if self.val = UInt32($93DA) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR' else
if self.val = UInt32($93DB) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x10' else
if self.val = UInt32($93DB) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR' else
if self.val = UInt32($93DC) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_12x10' else
if self.val = UInt32($93DC) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR' else
if self.val = UInt32($93DD) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_12x12' else
if self.val = UInt32($93DD) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR' else
if self.val = UInt32($93E0) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES' else
if self.val = UInt32($93E1) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES' else
if self.val = UInt32($93E2) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES' else
if self.val = UInt32($93E3) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES' else
if self.val = UInt32($93E4) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES' else
if self.val = UInt32($93E5) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES' else
if self.val = UInt32($93E6) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES' else
if self.val = UInt32($93E7) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES' else
if self.val = UInt32($93E8) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES' else
if self.val = UInt32($93E9) then Result := 'COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES' else
Result := self.val.ToString;
end;
end;
InternalFormatPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SAMPLES := new InternalFormatPName($80A9);
private static _GENERATE_MIPMAP := new InternalFormatPName($8191);
private static _INTERNALFORMAT_SUPPORTED := new InternalFormatPName($826F);
private static _INTERNALFORMAT_PREFERRED := new InternalFormatPName($8270);
private static _INTERNALFORMAT_RED_SIZE := new InternalFormatPName($8271);
private static _INTERNALFORMAT_GREEN_SIZE := new InternalFormatPName($8272);
private static _INTERNALFORMAT_BLUE_SIZE := new InternalFormatPName($8273);
private static _INTERNALFORMAT_ALPHA_SIZE := new InternalFormatPName($8274);
private static _INTERNALFORMAT_DEPTH_SIZE := new InternalFormatPName($8275);
private static _INTERNALFORMAT_STENCIL_SIZE := new InternalFormatPName($8276);
private static _INTERNALFORMAT_SHARED_SIZE := new InternalFormatPName($8277);
private static _INTERNALFORMAT_RED_TYPE := new InternalFormatPName($8278);
private static _INTERNALFORMAT_GREEN_TYPE := new InternalFormatPName($8279);
private static _INTERNALFORMAT_BLUE_TYPE := new InternalFormatPName($827A);
private static _INTERNALFORMAT_ALPHA_TYPE := new InternalFormatPName($827B);
private static _INTERNALFORMAT_DEPTH_TYPE := new InternalFormatPName($827C);
private static _INTERNALFORMAT_STENCIL_TYPE := new InternalFormatPName($827D);
private static _MAX_WIDTH := new InternalFormatPName($827E);
private static _MAX_HEIGHT := new InternalFormatPName($827F);
private static _MAX_DEPTH := new InternalFormatPName($8280);
private static _MAX_LAYERS := new InternalFormatPName($8281);
private static _COLOR_COMPONENTS := new InternalFormatPName($8283);
private static _COLOR_RENDERABLE := new InternalFormatPName($8286);
private static _DEPTH_RENDERABLE := new InternalFormatPName($8287);
private static _STENCIL_RENDERABLE := new InternalFormatPName($8288);
private static _FRAMEBUFFER_RENDERABLE := new InternalFormatPName($8289);
private static _FRAMEBUFFER_RENDERABLE_LAYERED := new InternalFormatPName($828A);
private static _FRAMEBUFFER_BLEND := new InternalFormatPName($828B);
private static _READ_PIXELS := new InternalFormatPName($828C);
private static _READ_PIXELS_FORMAT := new InternalFormatPName($828D);
private static _READ_PIXELS_TYPE := new InternalFormatPName($828E);
private static _TEXTURE_IMAGE_FORMAT := new InternalFormatPName($828F);
private static _TEXTURE_IMAGE_TYPE := new InternalFormatPName($8290);
private static _GET__TEXTURE_IMAGE_FORMAT := new InternalFormatPName($8291);
private static _GET__TEXTURE_IMAGE_TYPE := new InternalFormatPName($8292);
private static _MIPMAP := new InternalFormatPName($8293);
private static _AUTO_GENERATE_MIPMAP := new InternalFormatPName($8295);
private static _COLOR_ENCODING := new InternalFormatPName($8296);
private static _SRGB_READ := new InternalFormatPName($8297);
private static _SRGB_WRITE := new InternalFormatPName($8298);
private static _FILTER := new InternalFormatPName($829A);
private static _VERTEX_TEXTURE := new InternalFormatPName($829B);
private static _TESS_CONTROL_TEXTURE := new InternalFormatPName($829C);
private static _TESS_EVALUATION_TEXTURE := new InternalFormatPName($829D);
private static _GEOMETRY_TEXTURE := new InternalFormatPName($829E);
private static _FRAGMENT_TEXTURE := new InternalFormatPName($829F);
private static _COMPUTE_TEXTURE := new InternalFormatPName($82A0);
private static _TEXTURE_SHADOW := new InternalFormatPName($82A1);
private static _TEXTURE_GATHER := new InternalFormatPName($82A2);
private static _TEXTURE_GATHER_SHADOW := new InternalFormatPName($82A3);
private static _SHADER_IMAGE_LOAD := new InternalFormatPName($82A4);
private static _SHADER_IMAGE_STORE := new InternalFormatPName($82A5);
private static _SHADER_IMAGE_ATOMIC := new InternalFormatPName($82A6);
private static _IMAGE_TEXEL_SIZE := new InternalFormatPName($82A7);
private static _IMAGE_COMPATIBILITY_CLASS := new InternalFormatPName($82A8);
private static _IMAGE_PIXEL_FORMAT := new InternalFormatPName($82A9);
private static _IMAGE_PIXEL_TYPE := new InternalFormatPName($82AA);
private static _SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST := new InternalFormatPName($82AC);
private static _SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST := new InternalFormatPName($82AD);
private static _SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE := new InternalFormatPName($82AE);
private static _SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE := new InternalFormatPName($82AF);
private static _TEXTURE_COMPRESSED_BLOCK_WIDTH := new InternalFormatPName($82B1);
private static _TEXTURE_COMPRESSED_BLOCK_HEIGHT := new InternalFormatPName($82B2);
private static _TEXTURE_COMPRESSED_BLOCK_SIZE := new InternalFormatPName($82B3);
private static _CLEAR_BUFFER := new InternalFormatPName($82B4);
private static _TEXTURE_VIEW := new InternalFormatPName($82B5);
private static _VIEW_COMPATIBILITY_CLASS := new InternalFormatPName($82B6);
private static _TEXTURE_COMPRESSED := new InternalFormatPName($86A1);
private static _IMAGE_FORMAT_COMPATIBILITY_TYPE := new InternalFormatPName($90C7);
private static _CLEAR_TEXTURE := new InternalFormatPName($9365);
private static _NUM_SAMPLE_COUNTS := new InternalFormatPName($9380);
public static property SAMPLES: InternalFormatPName read _SAMPLES;
public static property GENERATE_MIPMAP: InternalFormatPName read _GENERATE_MIPMAP;
public static property INTERNALFORMAT_SUPPORTED: InternalFormatPName read _INTERNALFORMAT_SUPPORTED;
public static property INTERNALFORMAT_PREFERRED: InternalFormatPName read _INTERNALFORMAT_PREFERRED;
public static property INTERNALFORMAT_RED_SIZE: InternalFormatPName read _INTERNALFORMAT_RED_SIZE;
public static property INTERNALFORMAT_GREEN_SIZE: InternalFormatPName read _INTERNALFORMAT_GREEN_SIZE;
public static property INTERNALFORMAT_BLUE_SIZE: InternalFormatPName read _INTERNALFORMAT_BLUE_SIZE;
public static property INTERNALFORMAT_ALPHA_SIZE: InternalFormatPName read _INTERNALFORMAT_ALPHA_SIZE;
public static property INTERNALFORMAT_DEPTH_SIZE: InternalFormatPName read _INTERNALFORMAT_DEPTH_SIZE;
public static property INTERNALFORMAT_STENCIL_SIZE: InternalFormatPName read _INTERNALFORMAT_STENCIL_SIZE;
public static property INTERNALFORMAT_SHARED_SIZE: InternalFormatPName read _INTERNALFORMAT_SHARED_SIZE;
public static property INTERNALFORMAT_RED_TYPE: InternalFormatPName read _INTERNALFORMAT_RED_TYPE;
public static property INTERNALFORMAT_GREEN_TYPE: InternalFormatPName read _INTERNALFORMAT_GREEN_TYPE;
public static property INTERNALFORMAT_BLUE_TYPE: InternalFormatPName read _INTERNALFORMAT_BLUE_TYPE;
public static property INTERNALFORMAT_ALPHA_TYPE: InternalFormatPName read _INTERNALFORMAT_ALPHA_TYPE;
public static property INTERNALFORMAT_DEPTH_TYPE: InternalFormatPName read _INTERNALFORMAT_DEPTH_TYPE;
public static property INTERNALFORMAT_STENCIL_TYPE: InternalFormatPName read _INTERNALFORMAT_STENCIL_TYPE;
public static property MAX_WIDTH: InternalFormatPName read _MAX_WIDTH;
public static property MAX_HEIGHT: InternalFormatPName read _MAX_HEIGHT;
public static property MAX_DEPTH: InternalFormatPName read _MAX_DEPTH;
public static property MAX_LAYERS: InternalFormatPName read _MAX_LAYERS;
public static property COLOR_COMPONENTS: InternalFormatPName read _COLOR_COMPONENTS;
public static property COLOR_RENDERABLE: InternalFormatPName read _COLOR_RENDERABLE;
public static property DEPTH_RENDERABLE: InternalFormatPName read _DEPTH_RENDERABLE;
public static property STENCIL_RENDERABLE: InternalFormatPName read _STENCIL_RENDERABLE;
public static property FRAMEBUFFER_RENDERABLE: InternalFormatPName read _FRAMEBUFFER_RENDERABLE;
public static property FRAMEBUFFER_RENDERABLE_LAYERED: InternalFormatPName read _FRAMEBUFFER_RENDERABLE_LAYERED;
public static property FRAMEBUFFER_BLEND: InternalFormatPName read _FRAMEBUFFER_BLEND;
public static property READ_PIXELS: InternalFormatPName read _READ_PIXELS;
public static property READ_PIXELS_FORMAT: InternalFormatPName read _READ_PIXELS_FORMAT;
public static property READ_PIXELS_TYPE: InternalFormatPName read _READ_PIXELS_TYPE;
public static property TEXTURE_IMAGE_FORMAT: InternalFormatPName read _TEXTURE_IMAGE_FORMAT;
public static property TEXTURE_IMAGE_TYPE: InternalFormatPName read _TEXTURE_IMAGE_TYPE;
public static property GET__TEXTURE_IMAGE_FORMAT: InternalFormatPName read _GET__TEXTURE_IMAGE_FORMAT;
public static property GET__TEXTURE_IMAGE_TYPE: InternalFormatPName read _GET__TEXTURE_IMAGE_TYPE;
public static property MIPMAP: InternalFormatPName read _MIPMAP;
public static property AUTO_GENERATE_MIPMAP: InternalFormatPName read _AUTO_GENERATE_MIPMAP;
public static property COLOR_ENCODING: InternalFormatPName read _COLOR_ENCODING;
public static property SRGB_READ: InternalFormatPName read _SRGB_READ;
public static property SRGB_WRITE: InternalFormatPName read _SRGB_WRITE;
public static property FILTER: InternalFormatPName read _FILTER;
public static property VERTEX_TEXTURE: InternalFormatPName read _VERTEX_TEXTURE;
public static property TESS_CONTROL_TEXTURE: InternalFormatPName read _TESS_CONTROL_TEXTURE;
public static property TESS_EVALUATION_TEXTURE: InternalFormatPName read _TESS_EVALUATION_TEXTURE;
public static property GEOMETRY_TEXTURE: InternalFormatPName read _GEOMETRY_TEXTURE;
public static property FRAGMENT_TEXTURE: InternalFormatPName read _FRAGMENT_TEXTURE;
public static property COMPUTE_TEXTURE: InternalFormatPName read _COMPUTE_TEXTURE;
public static property TEXTURE_SHADOW: InternalFormatPName read _TEXTURE_SHADOW;
public static property TEXTURE_GATHER: InternalFormatPName read _TEXTURE_GATHER;
public static property TEXTURE_GATHER_SHADOW: InternalFormatPName read _TEXTURE_GATHER_SHADOW;
public static property SHADER_IMAGE_LOAD: InternalFormatPName read _SHADER_IMAGE_LOAD;
public static property SHADER_IMAGE_STORE: InternalFormatPName read _SHADER_IMAGE_STORE;
public static property SHADER_IMAGE_ATOMIC: InternalFormatPName read _SHADER_IMAGE_ATOMIC;
public static property IMAGE_TEXEL_SIZE: InternalFormatPName read _IMAGE_TEXEL_SIZE;
public static property IMAGE_COMPATIBILITY_CLASS: InternalFormatPName read _IMAGE_COMPATIBILITY_CLASS;
public static property IMAGE_PIXEL_FORMAT: InternalFormatPName read _IMAGE_PIXEL_FORMAT;
public static property IMAGE_PIXEL_TYPE: InternalFormatPName read _IMAGE_PIXEL_TYPE;
public static property SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST: InternalFormatPName read _SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST;
public static property SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST: InternalFormatPName read _SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST;
public static property SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE: InternalFormatPName read _SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE;
public static property SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE: InternalFormatPName read _SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE;
public static property TEXTURE_COMPRESSED_BLOCK_WIDTH: InternalFormatPName read _TEXTURE_COMPRESSED_BLOCK_WIDTH;
public static property TEXTURE_COMPRESSED_BLOCK_HEIGHT: InternalFormatPName read _TEXTURE_COMPRESSED_BLOCK_HEIGHT;
public static property TEXTURE_COMPRESSED_BLOCK_SIZE: InternalFormatPName read _TEXTURE_COMPRESSED_BLOCK_SIZE;
public static property CLEAR_BUFFER: InternalFormatPName read _CLEAR_BUFFER;
public static property TEXTURE_VIEW: InternalFormatPName read _TEXTURE_VIEW;
public static property VIEW_COMPATIBILITY_CLASS: InternalFormatPName read _VIEW_COMPATIBILITY_CLASS;
public static property TEXTURE_COMPRESSED: InternalFormatPName read _TEXTURE_COMPRESSED;
public static property IMAGE_FORMAT_COMPATIBILITY_TYPE: InternalFormatPName read _IMAGE_FORMAT_COMPATIBILITY_TYPE;
public static property CLEAR_TEXTURE: InternalFormatPName read _CLEAR_TEXTURE;
public static property NUM_SAMPLE_COUNTS: InternalFormatPName read _NUM_SAMPLE_COUNTS;
public function ToString: string; override;
begin
if self.val = UInt32($80A9) then Result := 'SAMPLES' else
if self.val = UInt32($8191) then Result := 'GENERATE_MIPMAP' else
if self.val = UInt32($826F) then Result := 'INTERNALFORMAT_SUPPORTED' else
if self.val = UInt32($8270) then Result := 'INTERNALFORMAT_PREFERRED' else
if self.val = UInt32($8271) then Result := 'INTERNALFORMAT_RED_SIZE' else
if self.val = UInt32($8272) then Result := 'INTERNALFORMAT_GREEN_SIZE' else
if self.val = UInt32($8273) then Result := 'INTERNALFORMAT_BLUE_SIZE' else
if self.val = UInt32($8274) then Result := 'INTERNALFORMAT_ALPHA_SIZE' else
if self.val = UInt32($8275) then Result := 'INTERNALFORMAT_DEPTH_SIZE' else
if self.val = UInt32($8276) then Result := 'INTERNALFORMAT_STENCIL_SIZE' else
if self.val = UInt32($8277) then Result := 'INTERNALFORMAT_SHARED_SIZE' else
if self.val = UInt32($8278) then Result := 'INTERNALFORMAT_RED_TYPE' else
if self.val = UInt32($8279) then Result := 'INTERNALFORMAT_GREEN_TYPE' else
if self.val = UInt32($827A) then Result := 'INTERNALFORMAT_BLUE_TYPE' else
if self.val = UInt32($827B) then Result := 'INTERNALFORMAT_ALPHA_TYPE' else
if self.val = UInt32($827C) then Result := 'INTERNALFORMAT_DEPTH_TYPE' else
if self.val = UInt32($827D) then Result := 'INTERNALFORMAT_STENCIL_TYPE' else
if self.val = UInt32($827E) then Result := 'MAX_WIDTH' else
if self.val = UInt32($827F) then Result := 'MAX_HEIGHT' else
if self.val = UInt32($8280) then Result := 'MAX_DEPTH' else
if self.val = UInt32($8281) then Result := 'MAX_LAYERS' else
if self.val = UInt32($8283) then Result := 'COLOR_COMPONENTS' else
if self.val = UInt32($8286) then Result := 'COLOR_RENDERABLE' else
if self.val = UInt32($8287) then Result := 'DEPTH_RENDERABLE' else
if self.val = UInt32($8288) then Result := 'STENCIL_RENDERABLE' else
if self.val = UInt32($8289) then Result := 'FRAMEBUFFER_RENDERABLE' else
if self.val = UInt32($828A) then Result := 'FRAMEBUFFER_RENDERABLE_LAYERED' else
if self.val = UInt32($828B) then Result := 'FRAMEBUFFER_BLEND' else
if self.val = UInt32($828C) then Result := 'READ_PIXELS' else
if self.val = UInt32($828D) then Result := 'READ_PIXELS_FORMAT' else
if self.val = UInt32($828E) then Result := 'READ_PIXELS_TYPE' else
if self.val = UInt32($828F) then Result := 'TEXTURE_IMAGE_FORMAT' else
if self.val = UInt32($8290) then Result := 'TEXTURE_IMAGE_TYPE' else
if self.val = UInt32($8291) then Result := 'GET__TEXTURE_IMAGE_FORMAT' else
if self.val = UInt32($8292) then Result := 'GET__TEXTURE_IMAGE_TYPE' else
if self.val = UInt32($8293) then Result := 'MIPMAP' else
if self.val = UInt32($8295) then Result := 'AUTO_GENERATE_MIPMAP' else
if self.val = UInt32($8296) then Result := 'COLOR_ENCODING' else
if self.val = UInt32($8297) then Result := 'SRGB_READ' else
if self.val = UInt32($8298) then Result := 'SRGB_WRITE' else
if self.val = UInt32($829A) then Result := 'FILTER' else
if self.val = UInt32($829B) then Result := 'VERTEX_TEXTURE' else
if self.val = UInt32($829C) then Result := 'TESS_CONTROL_TEXTURE' else
if self.val = UInt32($829D) then Result := 'TESS_EVALUATION_TEXTURE' else
if self.val = UInt32($829E) then Result := 'GEOMETRY_TEXTURE' else
if self.val = UInt32($829F) then Result := 'FRAGMENT_TEXTURE' else
if self.val = UInt32($82A0) then Result := 'COMPUTE_TEXTURE' else
if self.val = UInt32($82A1) then Result := 'TEXTURE_SHADOW' else
if self.val = UInt32($82A2) then Result := 'TEXTURE_GATHER' else
if self.val = UInt32($82A3) then Result := 'TEXTURE_GATHER_SHADOW' else
if self.val = UInt32($82A4) then Result := 'SHADER_IMAGE_LOAD' else
if self.val = UInt32($82A5) then Result := 'SHADER_IMAGE_STORE' else
if self.val = UInt32($82A6) then Result := 'SHADER_IMAGE_ATOMIC' else
if self.val = UInt32($82A7) then Result := 'IMAGE_TEXEL_SIZE' else
if self.val = UInt32($82A8) then Result := 'IMAGE_COMPATIBILITY_CLASS' else
if self.val = UInt32($82A9) then Result := 'IMAGE_PIXEL_FORMAT' else
if self.val = UInt32($82AA) then Result := 'IMAGE_PIXEL_TYPE' else
if self.val = UInt32($82AC) then Result := 'SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST' else
if self.val = UInt32($82AD) then Result := 'SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST' else
if self.val = UInt32($82AE) then Result := 'SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE' else
if self.val = UInt32($82AF) then Result := 'SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE' else
if self.val = UInt32($82B1) then Result := 'TEXTURE_COMPRESSED_BLOCK_WIDTH' else
if self.val = UInt32($82B2) then Result := 'TEXTURE_COMPRESSED_BLOCK_HEIGHT' else
if self.val = UInt32($82B3) then Result := 'TEXTURE_COMPRESSED_BLOCK_SIZE' else
if self.val = UInt32($82B4) then Result := 'CLEAR_BUFFER' else
if self.val = UInt32($82B5) then Result := 'TEXTURE_VIEW' else
if self.val = UInt32($82B6) then Result := 'VIEW_COMPATIBILITY_CLASS' else
if self.val = UInt32($86A1) then Result := 'TEXTURE_COMPRESSED' else
if self.val = UInt32($90C7) then Result := 'IMAGE_FORMAT_COMPATIBILITY_TYPE' else
if self.val = UInt32($9365) then Result := 'CLEAR_TEXTURE' else
if self.val = UInt32($9380) then Result := 'NUM_SAMPLE_COUNTS' else
Result := self.val.ToString;
end;
end;
InvalidateFramebufferAttachment = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR := new InvalidateFramebufferAttachment($1800);
private static _DEPTH := new InvalidateFramebufferAttachment($1801);
private static _STENCIL := new InvalidateFramebufferAttachment($1802);
private static _DEPTH_STENCIL_ATTACHMENT := new InvalidateFramebufferAttachment($821A);
private static _COLOR_ATTACHMENT0 := new InvalidateFramebufferAttachment($8CE0);
private static _COLOR_ATTACHMENT0_EXT := new InvalidateFramebufferAttachment($8CE0);
private static _COLOR_ATTACHMENT0_NV := new InvalidateFramebufferAttachment($8CE0);
private static _COLOR_ATTACHMENT0_OES := new InvalidateFramebufferAttachment($8CE0);
private static _COLOR_ATTACHMENT1 := new InvalidateFramebufferAttachment($8CE1);
private static _COLOR_ATTACHMENT1_EXT := new InvalidateFramebufferAttachment($8CE1);
private static _COLOR_ATTACHMENT1_NV := new InvalidateFramebufferAttachment($8CE1);
private static _COLOR_ATTACHMENT2 := new InvalidateFramebufferAttachment($8CE2);
private static _COLOR_ATTACHMENT2_EXT := new InvalidateFramebufferAttachment($8CE2);
private static _COLOR_ATTACHMENT2_NV := new InvalidateFramebufferAttachment($8CE2);
private static _COLOR_ATTACHMENT3 := new InvalidateFramebufferAttachment($8CE3);
private static _COLOR_ATTACHMENT3_EXT := new InvalidateFramebufferAttachment($8CE3);
private static _COLOR_ATTACHMENT3_NV := new InvalidateFramebufferAttachment($8CE3);
private static _COLOR_ATTACHMENT4 := new InvalidateFramebufferAttachment($8CE4);
private static _COLOR_ATTACHMENT4_EXT := new InvalidateFramebufferAttachment($8CE4);
private static _COLOR_ATTACHMENT4_NV := new InvalidateFramebufferAttachment($8CE4);
private static _COLOR_ATTACHMENT5 := new InvalidateFramebufferAttachment($8CE5);
private static _COLOR_ATTACHMENT5_EXT := new InvalidateFramebufferAttachment($8CE5);
private static _COLOR_ATTACHMENT5_NV := new InvalidateFramebufferAttachment($8CE5);
private static _COLOR_ATTACHMENT6 := new InvalidateFramebufferAttachment($8CE6);
private static _COLOR_ATTACHMENT6_EXT := new InvalidateFramebufferAttachment($8CE6);
private static _COLOR_ATTACHMENT6_NV := new InvalidateFramebufferAttachment($8CE6);
private static _COLOR_ATTACHMENT7 := new InvalidateFramebufferAttachment($8CE7);
private static _COLOR_ATTACHMENT7_EXT := new InvalidateFramebufferAttachment($8CE7);
private static _COLOR_ATTACHMENT7_NV := new InvalidateFramebufferAttachment($8CE7);
private static _COLOR_ATTACHMENT8 := new InvalidateFramebufferAttachment($8CE8);
private static _COLOR_ATTACHMENT8_EXT := new InvalidateFramebufferAttachment($8CE8);
private static _COLOR_ATTACHMENT8_NV := new InvalidateFramebufferAttachment($8CE8);
private static _COLOR_ATTACHMENT9 := new InvalidateFramebufferAttachment($8CE9);
private static _COLOR_ATTACHMENT9_EXT := new InvalidateFramebufferAttachment($8CE9);
private static _COLOR_ATTACHMENT9_NV := new InvalidateFramebufferAttachment($8CE9);
private static _COLOR_ATTACHMENT10 := new InvalidateFramebufferAttachment($8CEA);
private static _COLOR_ATTACHMENT10_EXT := new InvalidateFramebufferAttachment($8CEA);
private static _COLOR_ATTACHMENT10_NV := new InvalidateFramebufferAttachment($8CEA);
private static _COLOR_ATTACHMENT11 := new InvalidateFramebufferAttachment($8CEB);
private static _COLOR_ATTACHMENT11_EXT := new InvalidateFramebufferAttachment($8CEB);
private static _COLOR_ATTACHMENT11_NV := new InvalidateFramebufferAttachment($8CEB);
private static _COLOR_ATTACHMENT12 := new InvalidateFramebufferAttachment($8CEC);
private static _COLOR_ATTACHMENT12_EXT := new InvalidateFramebufferAttachment($8CEC);
private static _COLOR_ATTACHMENT12_NV := new InvalidateFramebufferAttachment($8CEC);
private static _COLOR_ATTACHMENT13 := new InvalidateFramebufferAttachment($8CED);
private static _COLOR_ATTACHMENT13_EXT := new InvalidateFramebufferAttachment($8CED);
private static _COLOR_ATTACHMENT13_NV := new InvalidateFramebufferAttachment($8CED);
private static _COLOR_ATTACHMENT14 := new InvalidateFramebufferAttachment($8CEE);
private static _COLOR_ATTACHMENT14_EXT := new InvalidateFramebufferAttachment($8CEE);
private static _COLOR_ATTACHMENT14_NV := new InvalidateFramebufferAttachment($8CEE);
private static _COLOR_ATTACHMENT15 := new InvalidateFramebufferAttachment($8CEF);
private static _COLOR_ATTACHMENT15_EXT := new InvalidateFramebufferAttachment($8CEF);
private static _COLOR_ATTACHMENT15_NV := new InvalidateFramebufferAttachment($8CEF);
private static _COLOR_ATTACHMENT16 := new InvalidateFramebufferAttachment($8CF0);
private static _COLOR_ATTACHMENT17 := new InvalidateFramebufferAttachment($8CF1);
private static _COLOR_ATTACHMENT18 := new InvalidateFramebufferAttachment($8CF2);
private static _COLOR_ATTACHMENT19 := new InvalidateFramebufferAttachment($8CF3);
private static _COLOR_ATTACHMENT20 := new InvalidateFramebufferAttachment($8CF4);
private static _COLOR_ATTACHMENT21 := new InvalidateFramebufferAttachment($8CF5);
private static _COLOR_ATTACHMENT22 := new InvalidateFramebufferAttachment($8CF6);
private static _COLOR_ATTACHMENT23 := new InvalidateFramebufferAttachment($8CF7);
private static _COLOR_ATTACHMENT24 := new InvalidateFramebufferAttachment($8CF8);
private static _COLOR_ATTACHMENT25 := new InvalidateFramebufferAttachment($8CF9);
private static _COLOR_ATTACHMENT26 := new InvalidateFramebufferAttachment($8CFA);
private static _COLOR_ATTACHMENT27 := new InvalidateFramebufferAttachment($8CFB);
private static _COLOR_ATTACHMENT28 := new InvalidateFramebufferAttachment($8CFC);
private static _COLOR_ATTACHMENT29 := new InvalidateFramebufferAttachment($8CFD);
private static _COLOR_ATTACHMENT30 := new InvalidateFramebufferAttachment($8CFE);
private static _COLOR_ATTACHMENT31 := new InvalidateFramebufferAttachment($8CFF);
private static _DEPTH_ATTACHMENT := new InvalidateFramebufferAttachment($8D00);
private static _DEPTH_ATTACHMENT_EXT := new InvalidateFramebufferAttachment($8D00);
private static _DEPTH_ATTACHMENT_OES := new InvalidateFramebufferAttachment($8D00);
private static _STENCIL_ATTACHMENT_EXT := new InvalidateFramebufferAttachment($8D20);
private static _STENCIL_ATTACHMENT_OES := new InvalidateFramebufferAttachment($8D20);
public static property COLOR: InvalidateFramebufferAttachment read _COLOR;
public static property DEPTH: InvalidateFramebufferAttachment read _DEPTH;
public static property STENCIL: InvalidateFramebufferAttachment read _STENCIL;
public static property DEPTH_STENCIL_ATTACHMENT: InvalidateFramebufferAttachment read _DEPTH_STENCIL_ATTACHMENT;
public static property COLOR_ATTACHMENT0: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT0;
public static property COLOR_ATTACHMENT0_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT0_EXT;
public static property COLOR_ATTACHMENT0_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT0_NV;
public static property COLOR_ATTACHMENT0_OES: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT0_OES;
public static property COLOR_ATTACHMENT1: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT1;
public static property COLOR_ATTACHMENT1_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT1_EXT;
public static property COLOR_ATTACHMENT1_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT1_NV;
public static property COLOR_ATTACHMENT2: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT2;
public static property COLOR_ATTACHMENT2_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT2_EXT;
public static property COLOR_ATTACHMENT2_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT2_NV;
public static property COLOR_ATTACHMENT3: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT3;
public static property COLOR_ATTACHMENT3_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT3_EXT;
public static property COLOR_ATTACHMENT3_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT3_NV;
public static property COLOR_ATTACHMENT4: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT4;
public static property COLOR_ATTACHMENT4_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT4_EXT;
public static property COLOR_ATTACHMENT4_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT4_NV;
public static property COLOR_ATTACHMENT5: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT5;
public static property COLOR_ATTACHMENT5_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT5_EXT;
public static property COLOR_ATTACHMENT5_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT5_NV;
public static property COLOR_ATTACHMENT6: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT6;
public static property COLOR_ATTACHMENT6_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT6_EXT;
public static property COLOR_ATTACHMENT6_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT6_NV;
public static property COLOR_ATTACHMENT7: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT7;
public static property COLOR_ATTACHMENT7_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT7_EXT;
public static property COLOR_ATTACHMENT7_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT7_NV;
public static property COLOR_ATTACHMENT8: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT8;
public static property COLOR_ATTACHMENT8_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT8_EXT;
public static property COLOR_ATTACHMENT8_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT8_NV;
public static property COLOR_ATTACHMENT9: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT9;
public static property COLOR_ATTACHMENT9_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT9_EXT;
public static property COLOR_ATTACHMENT9_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT9_NV;
public static property COLOR_ATTACHMENT10: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT10;
public static property COLOR_ATTACHMENT10_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT10_EXT;
public static property COLOR_ATTACHMENT10_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT10_NV;
public static property COLOR_ATTACHMENT11: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT11;
public static property COLOR_ATTACHMENT11_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT11_EXT;
public static property COLOR_ATTACHMENT11_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT11_NV;
public static property COLOR_ATTACHMENT12: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT12;
public static property COLOR_ATTACHMENT12_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT12_EXT;
public static property COLOR_ATTACHMENT12_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT12_NV;
public static property COLOR_ATTACHMENT13: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT13;
public static property COLOR_ATTACHMENT13_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT13_EXT;
public static property COLOR_ATTACHMENT13_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT13_NV;
public static property COLOR_ATTACHMENT14: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT14;
public static property COLOR_ATTACHMENT14_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT14_EXT;
public static property COLOR_ATTACHMENT14_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT14_NV;
public static property COLOR_ATTACHMENT15: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT15;
public static property COLOR_ATTACHMENT15_EXT: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT15_EXT;
public static property COLOR_ATTACHMENT15_NV: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT15_NV;
public static property COLOR_ATTACHMENT16: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT16;
public static property COLOR_ATTACHMENT17: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT17;
public static property COLOR_ATTACHMENT18: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT18;
public static property COLOR_ATTACHMENT19: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT19;
public static property COLOR_ATTACHMENT20: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT20;
public static property COLOR_ATTACHMENT21: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT21;
public static property COLOR_ATTACHMENT22: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT22;
public static property COLOR_ATTACHMENT23: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT23;
public static property COLOR_ATTACHMENT24: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT24;
public static property COLOR_ATTACHMENT25: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT25;
public static property COLOR_ATTACHMENT26: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT26;
public static property COLOR_ATTACHMENT27: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT27;
public static property COLOR_ATTACHMENT28: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT28;
public static property COLOR_ATTACHMENT29: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT29;
public static property COLOR_ATTACHMENT30: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT30;
public static property COLOR_ATTACHMENT31: InvalidateFramebufferAttachment read _COLOR_ATTACHMENT31;
public static property DEPTH_ATTACHMENT: InvalidateFramebufferAttachment read _DEPTH_ATTACHMENT;
public static property DEPTH_ATTACHMENT_EXT: InvalidateFramebufferAttachment read _DEPTH_ATTACHMENT_EXT;
public static property DEPTH_ATTACHMENT_OES: InvalidateFramebufferAttachment read _DEPTH_ATTACHMENT_OES;
public static property STENCIL_ATTACHMENT_EXT: InvalidateFramebufferAttachment read _STENCIL_ATTACHMENT_EXT;
public static property STENCIL_ATTACHMENT_OES: InvalidateFramebufferAttachment read _STENCIL_ATTACHMENT_OES;
public function ToString: string; override;
begin
if self.val = UInt32($1800) then Result := 'COLOR' else
if self.val = UInt32($1801) then Result := 'DEPTH' else
if self.val = UInt32($1802) then Result := 'STENCIL' else
if self.val = UInt32($821A) then Result := 'DEPTH_STENCIL_ATTACHMENT' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0_EXT' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0_NV' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0_OES' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1_EXT' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1_NV' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2_EXT' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2_NV' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3_EXT' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3_NV' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4_EXT' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4_NV' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5_EXT' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5_NV' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6_EXT' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6_NV' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7_EXT' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7_NV' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8_EXT' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8_NV' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9_EXT' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9_NV' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10_EXT' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10_NV' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11_EXT' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11_NV' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12_EXT' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12_NV' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13_EXT' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13_NV' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14_EXT' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14_NV' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15_EXT' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15_NV' else
if self.val = UInt32($8CF0) then Result := 'COLOR_ATTACHMENT16' else
if self.val = UInt32($8CF1) then Result := 'COLOR_ATTACHMENT17' else
if self.val = UInt32($8CF2) then Result := 'COLOR_ATTACHMENT18' else
if self.val = UInt32($8CF3) then Result := 'COLOR_ATTACHMENT19' else
if self.val = UInt32($8CF4) then Result := 'COLOR_ATTACHMENT20' else
if self.val = UInt32($8CF5) then Result := 'COLOR_ATTACHMENT21' else
if self.val = UInt32($8CF6) then Result := 'COLOR_ATTACHMENT22' else
if self.val = UInt32($8CF7) then Result := 'COLOR_ATTACHMENT23' else
if self.val = UInt32($8CF8) then Result := 'COLOR_ATTACHMENT24' else
if self.val = UInt32($8CF9) then Result := 'COLOR_ATTACHMENT25' else
if self.val = UInt32($8CFA) then Result := 'COLOR_ATTACHMENT26' else
if self.val = UInt32($8CFB) then Result := 'COLOR_ATTACHMENT27' else
if self.val = UInt32($8CFC) then Result := 'COLOR_ATTACHMENT28' else
if self.val = UInt32($8CFD) then Result := 'COLOR_ATTACHMENT29' else
if self.val = UInt32($8CFE) then Result := 'COLOR_ATTACHMENT30' else
if self.val = UInt32($8CFF) then Result := 'COLOR_ATTACHMENT31' else
if self.val = UInt32($8D00) then Result := 'DEPTH_ATTACHMENT' else
if self.val = UInt32($8D00) then Result := 'DEPTH_ATTACHMENT_EXT' else
if self.val = UInt32($8D00) then Result := 'DEPTH_ATTACHMENT_OES' else
if self.val = UInt32($8D20) then Result := 'STENCIL_ATTACHMENT_EXT' else
if self.val = UInt32($8D20) then Result := 'STENCIL_ATTACHMENT_OES' else
Result := self.val.ToString;
end;
end;
LightModelParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LIGHT_MODEL_LOCAL_VIEWER := new LightModelParameter($0B51);
private static _LIGHT_MODEL_TWO_SIDE := new LightModelParameter($0B52);
private static _LIGHT_MODEL_AMBIENT := new LightModelParameter($0B53);
private static _LIGHT_MODEL_COLOR_CONTROL := new LightModelParameter($81F8);
private static _LIGHT_MODEL_COLOR_CONTROL_EXT := new LightModelParameter($81F8);
public static property LIGHT_MODEL_LOCAL_VIEWER: LightModelParameter read _LIGHT_MODEL_LOCAL_VIEWER;
public static property LIGHT_MODEL_TWO_SIDE: LightModelParameter read _LIGHT_MODEL_TWO_SIDE;
public static property LIGHT_MODEL_AMBIENT: LightModelParameter read _LIGHT_MODEL_AMBIENT;
public static property LIGHT_MODEL_COLOR_CONTROL: LightModelParameter read _LIGHT_MODEL_COLOR_CONTROL;
public static property LIGHT_MODEL_COLOR_CONTROL_EXT: LightModelParameter read _LIGHT_MODEL_COLOR_CONTROL_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($0B51) then Result := 'LIGHT_MODEL_LOCAL_VIEWER' else
if self.val = UInt32($0B52) then Result := 'LIGHT_MODEL_TWO_SIDE' else
if self.val = UInt32($0B53) then Result := 'LIGHT_MODEL_AMBIENT' else
if self.val = UInt32($81F8) then Result := 'LIGHT_MODEL_COLOR_CONTROL' else
if self.val = UInt32($81F8) then Result := 'LIGHT_MODEL_COLOR_CONTROL_EXT' else
Result := self.val.ToString;
end;
end;
LightName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LIGHT0 := new LightName($4000);
private static _LIGHT1 := new LightName($4001);
private static _LIGHT2 := new LightName($4002);
private static _LIGHT3 := new LightName($4003);
private static _LIGHT4 := new LightName($4004);
private static _LIGHT5 := new LightName($4005);
private static _LIGHT6 := new LightName($4006);
private static _LIGHT7 := new LightName($4007);
private static _FRAGMENT_LIGHT0_SGIX := new LightName($840C);
private static _FRAGMENT_LIGHT1_SGIX := new LightName($840D);
private static _FRAGMENT_LIGHT2_SGIX := new LightName($840E);
private static _FRAGMENT_LIGHT3_SGIX := new LightName($840F);
private static _FRAGMENT_LIGHT4_SGIX := new LightName($8410);
private static _FRAGMENT_LIGHT5_SGIX := new LightName($8411);
private static _FRAGMENT_LIGHT6_SGIX := new LightName($8412);
private static _FRAGMENT_LIGHT7_SGIX := new LightName($8413);
public static property LIGHT0: LightName read _LIGHT0;
public static property LIGHT1: LightName read _LIGHT1;
public static property LIGHT2: LightName read _LIGHT2;
public static property LIGHT3: LightName read _LIGHT3;
public static property LIGHT4: LightName read _LIGHT4;
public static property LIGHT5: LightName read _LIGHT5;
public static property LIGHT6: LightName read _LIGHT6;
public static property LIGHT7: LightName read _LIGHT7;
public static property FRAGMENT_LIGHT0_SGIX: LightName read _FRAGMENT_LIGHT0_SGIX;
public static property FRAGMENT_LIGHT1_SGIX: LightName read _FRAGMENT_LIGHT1_SGIX;
public static property FRAGMENT_LIGHT2_SGIX: LightName read _FRAGMENT_LIGHT2_SGIX;
public static property FRAGMENT_LIGHT3_SGIX: LightName read _FRAGMENT_LIGHT3_SGIX;
public static property FRAGMENT_LIGHT4_SGIX: LightName read _FRAGMENT_LIGHT4_SGIX;
public static property FRAGMENT_LIGHT5_SGIX: LightName read _FRAGMENT_LIGHT5_SGIX;
public static property FRAGMENT_LIGHT6_SGIX: LightName read _FRAGMENT_LIGHT6_SGIX;
public static property FRAGMENT_LIGHT7_SGIX: LightName read _FRAGMENT_LIGHT7_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($4000) then Result := 'LIGHT0' else
if self.val = UInt32($4001) then Result := 'LIGHT1' else
if self.val = UInt32($4002) then Result := 'LIGHT2' else
if self.val = UInt32($4003) then Result := 'LIGHT3' else
if self.val = UInt32($4004) then Result := 'LIGHT4' else
if self.val = UInt32($4005) then Result := 'LIGHT5' else
if self.val = UInt32($4006) then Result := 'LIGHT6' else
if self.val = UInt32($4007) then Result := 'LIGHT7' else
if self.val = UInt32($840C) then Result := 'FRAGMENT_LIGHT0_SGIX' else
if self.val = UInt32($840D) then Result := 'FRAGMENT_LIGHT1_SGIX' else
if self.val = UInt32($840E) then Result := 'FRAGMENT_LIGHT2_SGIX' else
if self.val = UInt32($840F) then Result := 'FRAGMENT_LIGHT3_SGIX' else
if self.val = UInt32($8410) then Result := 'FRAGMENT_LIGHT4_SGIX' else
if self.val = UInt32($8411) then Result := 'FRAGMENT_LIGHT5_SGIX' else
if self.val = UInt32($8412) then Result := 'FRAGMENT_LIGHT6_SGIX' else
if self.val = UInt32($8413) then Result := 'FRAGMENT_LIGHT7_SGIX' else
Result := self.val.ToString;
end;
end;
LightParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POSITION := new LightParameter($1203);
private static _SPOT_DIRECTION := new LightParameter($1204);
private static _SPOT_EXPONENT := new LightParameter($1205);
private static _SPOT_CUTOFF := new LightParameter($1206);
private static _CONSTANT_ATTENUATION := new LightParameter($1207);
private static _LINEAR_ATTENUATION := new LightParameter($1208);
private static _QUADRATIC_ATTENUATION := new LightParameter($1209);
public static property POSITION: LightParameter read _POSITION;
public static property SPOT_DIRECTION: LightParameter read _SPOT_DIRECTION;
public static property SPOT_EXPONENT: LightParameter read _SPOT_EXPONENT;
public static property SPOT_CUTOFF: LightParameter read _SPOT_CUTOFF;
public static property CONSTANT_ATTENUATION: LightParameter read _CONSTANT_ATTENUATION;
public static property LINEAR_ATTENUATION: LightParameter read _LINEAR_ATTENUATION;
public static property QUADRATIC_ATTENUATION: LightParameter read _QUADRATIC_ATTENUATION;
public function ToString: string; override;
begin
if self.val = UInt32($1203) then Result := 'POSITION' else
if self.val = UInt32($1204) then Result := 'SPOT_DIRECTION' else
if self.val = UInt32($1205) then Result := 'SPOT_EXPONENT' else
if self.val = UInt32($1206) then Result := 'SPOT_CUTOFF' else
if self.val = UInt32($1207) then Result := 'CONSTANT_ATTENUATION' else
if self.val = UInt32($1208) then Result := 'LINEAR_ATTENUATION' else
if self.val = UInt32($1209) then Result := 'QUADRATIC_ATTENUATION' else
Result := self.val.ToString;
end;
end;
ListMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COMPILE := new ListMode($1300);
private static _COMPILE_AND_EXECUTE := new ListMode($1301);
public static property COMPILE: ListMode read _COMPILE;
public static property COMPILE_AND_EXECUTE: ListMode read _COMPILE_AND_EXECUTE;
public function ToString: string; override;
begin
if self.val = UInt32($1300) then Result := 'COMPILE' else
if self.val = UInt32($1301) then Result := 'COMPILE_AND_EXECUTE' else
Result := self.val.ToString;
end;
end;
ListNameType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new ListNameType($1400);
private static _UNSIGNED_BYTE := new ListNameType($1401);
private static _SHORT := new ListNameType($1402);
private static _UNSIGNED_SHORT := new ListNameType($1403);
private static _INT := new ListNameType($1404);
private static _UNSIGNED_INT := new ListNameType($1405);
private static _FLOAT := new ListNameType($1406);
private static _GL_2_BYTES := new ListNameType($1407);
private static _GL_3_BYTES := new ListNameType($1408);
private static _GL_4_BYTES := new ListNameType($1409);
public static property BYTE: ListNameType read _BYTE;
public static property UNSIGNED_BYTE: ListNameType read _UNSIGNED_BYTE;
public static property SHORT: ListNameType read _SHORT;
public static property UNSIGNED_SHORT: ListNameType read _UNSIGNED_SHORT;
public static property INT: ListNameType read _INT;
public static property UNSIGNED_INT: ListNameType read _UNSIGNED_INT;
public static property FLOAT: ListNameType read _FLOAT;
public static property GL_2_BYTES: ListNameType read _GL_2_BYTES;
public static property GL_3_BYTES: ListNameType read _GL_3_BYTES;
public static property GL_4_BYTES: ListNameType read _GL_4_BYTES;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($1407) then Result := 'GL_2_BYTES' else
if self.val = UInt32($1408) then Result := 'GL_3_BYTES' else
if self.val = UInt32($1409) then Result := 'GL_4_BYTES' else
Result := self.val.ToString;
end;
end;
ListParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LIST_PRIORITY_SGIX := new ListParameterName($8182);
public static property LIST_PRIORITY_SGIX: ListParameterName read _LIST_PRIORITY_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8182) then Result := 'LIST_PRIORITY_SGIX' else
Result := self.val.ToString;
end;
end;
LogicOp = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CLEAR := new LogicOp($1500);
private static _AND := new LogicOp($1501);
private static _AND_REVERSE := new LogicOp($1502);
private static _COPY := new LogicOp($1503);
private static _AND_INVERTED := new LogicOp($1504);
private static _NOOP := new LogicOp($1505);
private static _XOR := new LogicOp($1506);
private static _OR := new LogicOp($1507);
private static _NOR := new LogicOp($1508);
private static _EQUIV := new LogicOp($1509);
private static _INVERT := new LogicOp($150A);
private static _OR_REVERSE := new LogicOp($150B);
private static _COPY_INVERTED := new LogicOp($150C);
private static _OR_INVERTED := new LogicOp($150D);
private static _NAND := new LogicOp($150E);
private static _SET := new LogicOp($150F);
public static property CLEAR: LogicOp read _CLEAR;
public static property &AND: LogicOp read _AND;
public static property AND_REVERSE: LogicOp read _AND_REVERSE;
public static property COPY: LogicOp read _COPY;
public static property AND_INVERTED: LogicOp read _AND_INVERTED;
public static property NOOP: LogicOp read _NOOP;
public static property &XOR: LogicOp read _XOR;
public static property &OR: LogicOp read _OR;
public static property NOR: LogicOp read _NOR;
public static property EQUIV: LogicOp read _EQUIV;
public static property INVERT: LogicOp read _INVERT;
public static property OR_REVERSE: LogicOp read _OR_REVERSE;
public static property COPY_INVERTED: LogicOp read _COPY_INVERTED;
public static property OR_INVERTED: LogicOp read _OR_INVERTED;
public static property NAND: LogicOp read _NAND;
public static property &SET: LogicOp read _SET;
public function ToString: string; override;
begin
if self.val = UInt32($1500) then Result := 'CLEAR' else
if self.val = UInt32($1501) then Result := 'AND' else
if self.val = UInt32($1502) then Result := 'AND_REVERSE' else
if self.val = UInt32($1503) then Result := 'COPY' else
if self.val = UInt32($1504) then Result := 'AND_INVERTED' else
if self.val = UInt32($1505) then Result := 'NOOP' else
if self.val = UInt32($1506) then Result := 'XOR' else
if self.val = UInt32($1507) then Result := 'OR' else
if self.val = UInt32($1508) then Result := 'NOR' else
if self.val = UInt32($1509) then Result := 'EQUIV' else
if self.val = UInt32($150A) then Result := 'INVERT' else
if self.val = UInt32($150B) then Result := 'OR_REVERSE' else
if self.val = UInt32($150C) then Result := 'COPY_INVERTED' else
if self.val = UInt32($150D) then Result := 'OR_INVERTED' else
if self.val = UInt32($150E) then Result := 'NAND' else
if self.val = UInt32($150F) then Result := 'SET' else
Result := self.val.ToString;
end;
end;
MapBufferAccessMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP_READ_BIT := new MapBufferAccessMask($0001);
private static _MAP_READ_BIT_EXT := new MapBufferAccessMask($0001);
private static _MAP_WRITE_BIT := new MapBufferAccessMask($0002);
private static _MAP_WRITE_BIT_EXT := new MapBufferAccessMask($0002);
private static _MAP_INVALIDATE_RANGE_BIT := new MapBufferAccessMask($0004);
private static _MAP_INVALIDATE_RANGE_BIT_EXT := new MapBufferAccessMask($0004);
private static _MAP_INVALIDATE_BUFFER_BIT := new MapBufferAccessMask($0008);
private static _MAP_INVALIDATE_BUFFER_BIT_EXT := new MapBufferAccessMask($0008);
private static _MAP_FLUSH_EXPLICIT_BIT := new MapBufferAccessMask($0010);
private static _MAP_FLUSH_EXPLICIT_BIT_EXT := new MapBufferAccessMask($0010);
private static _MAP_UNSYNCHRONIZED_BIT := new MapBufferAccessMask($0020);
private static _MAP_UNSYNCHRONIZED_BIT_EXT := new MapBufferAccessMask($0020);
private static _MAP_PERSISTENT_BIT := new MapBufferAccessMask($0040);
private static _MAP_PERSISTENT_BIT_EXT := new MapBufferAccessMask($0040);
private static _MAP_COHERENT_BIT := new MapBufferAccessMask($0080);
private static _MAP_COHERENT_BIT_EXT := new MapBufferAccessMask($0080);
public static property MAP_READ_BIT: MapBufferAccessMask read _MAP_READ_BIT;
public static property MAP_READ_BIT_EXT: MapBufferAccessMask read _MAP_READ_BIT_EXT;
public static property MAP_WRITE_BIT: MapBufferAccessMask read _MAP_WRITE_BIT;
public static property MAP_WRITE_BIT_EXT: MapBufferAccessMask read _MAP_WRITE_BIT_EXT;
public static property MAP_INVALIDATE_RANGE_BIT: MapBufferAccessMask read _MAP_INVALIDATE_RANGE_BIT;
public static property MAP_INVALIDATE_RANGE_BIT_EXT: MapBufferAccessMask read _MAP_INVALIDATE_RANGE_BIT_EXT;
public static property MAP_INVALIDATE_BUFFER_BIT: MapBufferAccessMask read _MAP_INVALIDATE_BUFFER_BIT;
public static property MAP_INVALIDATE_BUFFER_BIT_EXT: MapBufferAccessMask read _MAP_INVALIDATE_BUFFER_BIT_EXT;
public static property MAP_FLUSH_EXPLICIT_BIT: MapBufferAccessMask read _MAP_FLUSH_EXPLICIT_BIT;
public static property MAP_FLUSH_EXPLICIT_BIT_EXT: MapBufferAccessMask read _MAP_FLUSH_EXPLICIT_BIT_EXT;
public static property MAP_UNSYNCHRONIZED_BIT: MapBufferAccessMask read _MAP_UNSYNCHRONIZED_BIT;
public static property MAP_UNSYNCHRONIZED_BIT_EXT: MapBufferAccessMask read _MAP_UNSYNCHRONIZED_BIT_EXT;
public static property MAP_PERSISTENT_BIT: MapBufferAccessMask read _MAP_PERSISTENT_BIT;
public static property MAP_PERSISTENT_BIT_EXT: MapBufferAccessMask read _MAP_PERSISTENT_BIT_EXT;
public static property MAP_COHERENT_BIT: MapBufferAccessMask read _MAP_COHERENT_BIT;
public static property MAP_COHERENT_BIT_EXT: MapBufferAccessMask read _MAP_COHERENT_BIT_EXT;
public static function operator or(f1,f2: MapBufferAccessMask) := new MapBufferAccessMask(f1.val or f2.val);
public property HAS_FLAG_MAP_READ_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_MAP_READ_BIT_EXT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_MAP_WRITE_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_MAP_WRITE_BIT_EXT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_MAP_INVALIDATE_RANGE_BIT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_MAP_INVALIDATE_RANGE_BIT_EXT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_MAP_INVALIDATE_BUFFER_BIT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_MAP_INVALIDATE_BUFFER_BIT_EXT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_MAP_FLUSH_EXPLICIT_BIT: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_MAP_FLUSH_EXPLICIT_BIT_EXT: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_MAP_UNSYNCHRONIZED_BIT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_MAP_UNSYNCHRONIZED_BIT_EXT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_MAP_PERSISTENT_BIT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_MAP_PERSISTENT_BIT_EXT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_MAP_COHERENT_BIT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_MAP_COHERENT_BIT_EXT: boolean read self.val and $0080 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'MAP_READ_BIT+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'MAP_READ_BIT_EXT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'MAP_WRITE_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'MAP_WRITE_BIT_EXT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'MAP_INVALIDATE_RANGE_BIT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'MAP_INVALIDATE_RANGE_BIT_EXT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'MAP_INVALIDATE_BUFFER_BIT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'MAP_INVALIDATE_BUFFER_BIT_EXT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'MAP_FLUSH_EXPLICIT_BIT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'MAP_FLUSH_EXPLICIT_BIT_EXT+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'MAP_UNSYNCHRONIZED_BIT+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'MAP_UNSYNCHRONIZED_BIT_EXT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'MAP_PERSISTENT_BIT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'MAP_PERSISTENT_BIT_EXT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'MAP_COHERENT_BIT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'MAP_COHERENT_BIT_EXT+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
MapQuery = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COEFF := new MapQuery($0A00);
private static _ORDER := new MapQuery($0A01);
private static _DOMAIN := new MapQuery($0A02);
public static property COEFF: MapQuery read _COEFF;
public static property ORDER: MapQuery read _ORDER;
public static property DOMAIN: MapQuery read _DOMAIN;
public function ToString: string; override;
begin
if self.val = UInt32($0A00) then Result := 'COEFF' else
if self.val = UInt32($0A01) then Result := 'ORDER' else
if self.val = UInt32($0A02) then Result := 'DOMAIN' else
Result := self.val.ToString;
end;
end;
MapTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP1_COLOR_4 := new MapTarget($0D90);
private static _MAP1_INDEX := new MapTarget($0D91);
private static _MAP1_NORMAL := new MapTarget($0D92);
private static _MAP1_TEXTURE_COORD_1 := new MapTarget($0D93);
private static _MAP1_TEXTURE_COORD_2 := new MapTarget($0D94);
private static _MAP1_TEXTURE_COORD_3 := new MapTarget($0D95);
private static _MAP1_TEXTURE_COORD_4 := new MapTarget($0D96);
private static _MAP1_VERTEX_3 := new MapTarget($0D97);
private static _MAP1_VERTEX_4 := new MapTarget($0D98);
private static _MAP2_COLOR_4 := new MapTarget($0DB0);
private static _MAP2_INDEX := new MapTarget($0DB1);
private static _MAP2_NORMAL := new MapTarget($0DB2);
private static _MAP2_TEXTURE_COORD_1 := new MapTarget($0DB3);
private static _MAP2_TEXTURE_COORD_2 := new MapTarget($0DB4);
private static _MAP2_TEXTURE_COORD_3 := new MapTarget($0DB5);
private static _MAP2_TEXTURE_COORD_4 := new MapTarget($0DB6);
private static _MAP2_VERTEX_3 := new MapTarget($0DB7);
private static _MAP2_VERTEX_4 := new MapTarget($0DB8);
private static _GEOMETRY_DEFORMATION_SGIX := new MapTarget($8194);
private static _TEXTURE_DEFORMATION_SGIX := new MapTarget($8195);
public static property MAP1_COLOR_4: MapTarget read _MAP1_COLOR_4;
public static property MAP1_INDEX: MapTarget read _MAP1_INDEX;
public static property MAP1_NORMAL: MapTarget read _MAP1_NORMAL;
public static property MAP1_TEXTURE_COORD_1: MapTarget read _MAP1_TEXTURE_COORD_1;
public static property MAP1_TEXTURE_COORD_2: MapTarget read _MAP1_TEXTURE_COORD_2;
public static property MAP1_TEXTURE_COORD_3: MapTarget read _MAP1_TEXTURE_COORD_3;
public static property MAP1_TEXTURE_COORD_4: MapTarget read _MAP1_TEXTURE_COORD_4;
public static property MAP1_VERTEX_3: MapTarget read _MAP1_VERTEX_3;
public static property MAP1_VERTEX_4: MapTarget read _MAP1_VERTEX_4;
public static property MAP2_COLOR_4: MapTarget read _MAP2_COLOR_4;
public static property MAP2_INDEX: MapTarget read _MAP2_INDEX;
public static property MAP2_NORMAL: MapTarget read _MAP2_NORMAL;
public static property MAP2_TEXTURE_COORD_1: MapTarget read _MAP2_TEXTURE_COORD_1;
public static property MAP2_TEXTURE_COORD_2: MapTarget read _MAP2_TEXTURE_COORD_2;
public static property MAP2_TEXTURE_COORD_3: MapTarget read _MAP2_TEXTURE_COORD_3;
public static property MAP2_TEXTURE_COORD_4: MapTarget read _MAP2_TEXTURE_COORD_4;
public static property MAP2_VERTEX_3: MapTarget read _MAP2_VERTEX_3;
public static property MAP2_VERTEX_4: MapTarget read _MAP2_VERTEX_4;
public static property GEOMETRY_DEFORMATION_SGIX: MapTarget read _GEOMETRY_DEFORMATION_SGIX;
public static property TEXTURE_DEFORMATION_SGIX: MapTarget read _TEXTURE_DEFORMATION_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($0D90) then Result := 'MAP1_COLOR_4' else
if self.val = UInt32($0D91) then Result := 'MAP1_INDEX' else
if self.val = UInt32($0D92) then Result := 'MAP1_NORMAL' else
if self.val = UInt32($0D93) then Result := 'MAP1_TEXTURE_COORD_1' else
if self.val = UInt32($0D94) then Result := 'MAP1_TEXTURE_COORD_2' else
if self.val = UInt32($0D95) then Result := 'MAP1_TEXTURE_COORD_3' else
if self.val = UInt32($0D96) then Result := 'MAP1_TEXTURE_COORD_4' else
if self.val = UInt32($0D97) then Result := 'MAP1_VERTEX_3' else
if self.val = UInt32($0D98) then Result := 'MAP1_VERTEX_4' else
if self.val = UInt32($0DB0) then Result := 'MAP2_COLOR_4' else
if self.val = UInt32($0DB1) then Result := 'MAP2_INDEX' else
if self.val = UInt32($0DB2) then Result := 'MAP2_NORMAL' else
if self.val = UInt32($0DB3) then Result := 'MAP2_TEXTURE_COORD_1' else
if self.val = UInt32($0DB4) then Result := 'MAP2_TEXTURE_COORD_2' else
if self.val = UInt32($0DB5) then Result := 'MAP2_TEXTURE_COORD_3' else
if self.val = UInt32($0DB6) then Result := 'MAP2_TEXTURE_COORD_4' else
if self.val = UInt32($0DB7) then Result := 'MAP2_VERTEX_3' else
if self.val = UInt32($0DB8) then Result := 'MAP2_VERTEX_4' else
if self.val = UInt32($8194) then Result := 'GEOMETRY_DEFORMATION_SGIX' else
if self.val = UInt32($8195) then Result := 'TEXTURE_DEFORMATION_SGIX' else
Result := self.val.ToString;
end;
end;
MaterialFace = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRONT := new MaterialFace($0404);
private static _BACK := new MaterialFace($0405);
private static _FRONT_AND_BACK := new MaterialFace($0408);
public static property FRONT: MaterialFace read _FRONT;
public static property BACK: MaterialFace read _BACK;
public static property FRONT_AND_BACK: MaterialFace read _FRONT_AND_BACK;
public function ToString: string; override;
begin
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0408) then Result := 'FRONT_AND_BACK' else
Result := self.val.ToString;
end;
end;
MaterialParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _AMBIENT := new MaterialParameter($1200);
private static _DIFFUSE := new MaterialParameter($1201);
private static _SPECULAR := new MaterialParameter($1202);
private static _EMISSION := new MaterialParameter($1600);
private static _SHININESS := new MaterialParameter($1601);
private static _AMBIENT_AND_DIFFUSE := new MaterialParameter($1602);
private static _COLOR_INDEXES := new MaterialParameter($1603);
public static property AMBIENT: MaterialParameter read _AMBIENT;
public static property DIFFUSE: MaterialParameter read _DIFFUSE;
public static property SPECULAR: MaterialParameter read _SPECULAR;
public static property EMISSION: MaterialParameter read _EMISSION;
public static property SHININESS: MaterialParameter read _SHININESS;
public static property AMBIENT_AND_DIFFUSE: MaterialParameter read _AMBIENT_AND_DIFFUSE;
public static property COLOR_INDEXES: MaterialParameter read _COLOR_INDEXES;
public function ToString: string; override;
begin
if self.val = UInt32($1200) then Result := 'AMBIENT' else
if self.val = UInt32($1201) then Result := 'DIFFUSE' else
if self.val = UInt32($1202) then Result := 'SPECULAR' else
if self.val = UInt32($1600) then Result := 'EMISSION' else
if self.val = UInt32($1601) then Result := 'SHININESS' else
if self.val = UInt32($1602) then Result := 'AMBIENT_AND_DIFFUSE' else
if self.val = UInt32($1603) then Result := 'COLOR_INDEXES' else
Result := self.val.ToString;
end;
end;
MatrixMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MODELVIEW := new MatrixMode($1700);
private static _MODELVIEW0_EXT := new MatrixMode($1700);
private static _PROJECTION := new MatrixMode($1701);
private static _TEXTURE := new MatrixMode($1702);
public static property MODELVIEW: MatrixMode read _MODELVIEW;
public static property MODELVIEW0_EXT: MatrixMode read _MODELVIEW0_EXT;
public static property PROJECTION: MatrixMode read _PROJECTION;
public static property TEXTURE: MatrixMode read _TEXTURE;
public function ToString: string; override;
begin
if self.val = UInt32($1700) then Result := 'MODELVIEW' else
if self.val = UInt32($1700) then Result := 'MODELVIEW0_EXT' else
if self.val = UInt32($1701) then Result := 'PROJECTION' else
if self.val = UInt32($1702) then Result := 'TEXTURE' else
Result := self.val.ToString;
end;
end;
MemoryBarrierMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_ATTRIB_ARRAY_BARRIER_BIT := new MemoryBarrierMask($0001);
private static _VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT := new MemoryBarrierMask($0001);
private static _ELEMENT_ARRAY_BARRIER_BIT := new MemoryBarrierMask($0002);
private static _ELEMENT_ARRAY_BARRIER_BIT_EXT := new MemoryBarrierMask($0002);
private static _UNIFORM_BARRIER_BIT := new MemoryBarrierMask($0004);
private static _UNIFORM_BARRIER_BIT_EXT := new MemoryBarrierMask($0004);
private static _TEXTURE_FETCH_BARRIER_BIT := new MemoryBarrierMask($0008);
private static _TEXTURE_FETCH_BARRIER_BIT_EXT := new MemoryBarrierMask($0008);
private static _SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV := new MemoryBarrierMask($0010);
private static _SHADER_IMAGE_ACCESS_BARRIER_BIT := new MemoryBarrierMask($0020);
private static _SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT := new MemoryBarrierMask($0020);
private static _COMMAND_BARRIER_BIT := new MemoryBarrierMask($0040);
private static _COMMAND_BARRIER_BIT_EXT := new MemoryBarrierMask($0040);
private static _PIXEL_BUFFER_BARRIER_BIT := new MemoryBarrierMask($0080);
private static _PIXEL_BUFFER_BARRIER_BIT_EXT := new MemoryBarrierMask($0080);
private static _TEXTURE_UPDATE_BARRIER_BIT := new MemoryBarrierMask($0100);
private static _TEXTURE_UPDATE_BARRIER_BIT_EXT := new MemoryBarrierMask($0100);
private static _BUFFER_UPDATE_BARRIER_BIT := new MemoryBarrierMask($0200);
private static _BUFFER_UPDATE_BARRIER_BIT_EXT := new MemoryBarrierMask($0200);
private static _FRAMEBUFFER_BARRIER_BIT := new MemoryBarrierMask($0400);
private static _FRAMEBUFFER_BARRIER_BIT_EXT := new MemoryBarrierMask($0400);
private static _TRANSFORM_FEEDBACK_BARRIER_BIT := new MemoryBarrierMask($0800);
private static _TRANSFORM_FEEDBACK_BARRIER_BIT_EXT := new MemoryBarrierMask($0800);
private static _ATOMIC_COUNTER_BARRIER_BIT := new MemoryBarrierMask($1000);
private static _ATOMIC_COUNTER_BARRIER_BIT_EXT := new MemoryBarrierMask($1000);
private static _SHADER_STORAGE_BARRIER_BIT := new MemoryBarrierMask($2000);
private static _CLIENT_MAPPED_BUFFER_BARRIER_BIT := new MemoryBarrierMask($4000);
private static _CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT := new MemoryBarrierMask($4000);
private static _QUERY_BUFFER_BARRIER_BIT := new MemoryBarrierMask($8000);
private static _ALL_BARRIER_BITS := new MemoryBarrierMask($FFFFFFFF);
private static _ALL_BARRIER_BITS_EXT := new MemoryBarrierMask($FFFFFFFF);
public static property VERTEX_ATTRIB_ARRAY_BARRIER_BIT: MemoryBarrierMask read _VERTEX_ATTRIB_ARRAY_BARRIER_BIT;
public static property VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT: MemoryBarrierMask read _VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT;
public static property ELEMENT_ARRAY_BARRIER_BIT: MemoryBarrierMask read _ELEMENT_ARRAY_BARRIER_BIT;
public static property ELEMENT_ARRAY_BARRIER_BIT_EXT: MemoryBarrierMask read _ELEMENT_ARRAY_BARRIER_BIT_EXT;
public static property UNIFORM_BARRIER_BIT: MemoryBarrierMask read _UNIFORM_BARRIER_BIT;
public static property UNIFORM_BARRIER_BIT_EXT: MemoryBarrierMask read _UNIFORM_BARRIER_BIT_EXT;
public static property TEXTURE_FETCH_BARRIER_BIT: MemoryBarrierMask read _TEXTURE_FETCH_BARRIER_BIT;
public static property TEXTURE_FETCH_BARRIER_BIT_EXT: MemoryBarrierMask read _TEXTURE_FETCH_BARRIER_BIT_EXT;
public static property SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV: MemoryBarrierMask read _SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV;
public static property SHADER_IMAGE_ACCESS_BARRIER_BIT: MemoryBarrierMask read _SHADER_IMAGE_ACCESS_BARRIER_BIT;
public static property SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT: MemoryBarrierMask read _SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT;
public static property COMMAND_BARRIER_BIT: MemoryBarrierMask read _COMMAND_BARRIER_BIT;
public static property COMMAND_BARRIER_BIT_EXT: MemoryBarrierMask read _COMMAND_BARRIER_BIT_EXT;
public static property PIXEL_BUFFER_BARRIER_BIT: MemoryBarrierMask read _PIXEL_BUFFER_BARRIER_BIT;
public static property PIXEL_BUFFER_BARRIER_BIT_EXT: MemoryBarrierMask read _PIXEL_BUFFER_BARRIER_BIT_EXT;
public static property TEXTURE_UPDATE_BARRIER_BIT: MemoryBarrierMask read _TEXTURE_UPDATE_BARRIER_BIT;
public static property TEXTURE_UPDATE_BARRIER_BIT_EXT: MemoryBarrierMask read _TEXTURE_UPDATE_BARRIER_BIT_EXT;
public static property BUFFER_UPDATE_BARRIER_BIT: MemoryBarrierMask read _BUFFER_UPDATE_BARRIER_BIT;
public static property BUFFER_UPDATE_BARRIER_BIT_EXT: MemoryBarrierMask read _BUFFER_UPDATE_BARRIER_BIT_EXT;
public static property FRAMEBUFFER_BARRIER_BIT: MemoryBarrierMask read _FRAMEBUFFER_BARRIER_BIT;
public static property FRAMEBUFFER_BARRIER_BIT_EXT: MemoryBarrierMask read _FRAMEBUFFER_BARRIER_BIT_EXT;
public static property TRANSFORM_FEEDBACK_BARRIER_BIT: MemoryBarrierMask read _TRANSFORM_FEEDBACK_BARRIER_BIT;
public static property TRANSFORM_FEEDBACK_BARRIER_BIT_EXT: MemoryBarrierMask read _TRANSFORM_FEEDBACK_BARRIER_BIT_EXT;
public static property ATOMIC_COUNTER_BARRIER_BIT: MemoryBarrierMask read _ATOMIC_COUNTER_BARRIER_BIT;
public static property ATOMIC_COUNTER_BARRIER_BIT_EXT: MemoryBarrierMask read _ATOMIC_COUNTER_BARRIER_BIT_EXT;
public static property SHADER_STORAGE_BARRIER_BIT: MemoryBarrierMask read _SHADER_STORAGE_BARRIER_BIT;
public static property CLIENT_MAPPED_BUFFER_BARRIER_BIT: MemoryBarrierMask read _CLIENT_MAPPED_BUFFER_BARRIER_BIT;
public static property CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT: MemoryBarrierMask read _CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT;
public static property QUERY_BUFFER_BARRIER_BIT: MemoryBarrierMask read _QUERY_BUFFER_BARRIER_BIT;
public static property ALL_BARRIER_BITS: MemoryBarrierMask read _ALL_BARRIER_BITS;
public static property ALL_BARRIER_BITS_EXT: MemoryBarrierMask read _ALL_BARRIER_BITS_EXT;
public static function operator or(f1,f2: MemoryBarrierMask) := new MemoryBarrierMask(f1.val or f2.val);
public property HAS_FLAG_VERTEX_ATTRIB_ARRAY_BARRIER_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_ELEMENT_ARRAY_BARRIER_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_ELEMENT_ARRAY_BARRIER_BIT_EXT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_UNIFORM_BARRIER_BIT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_UNIFORM_BARRIER_BIT_EXT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_TEXTURE_FETCH_BARRIER_BIT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_TEXTURE_FETCH_BARRIER_BIT_EXT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_SHADER_IMAGE_ACCESS_BARRIER_BIT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_COMMAND_BARRIER_BIT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_COMMAND_BARRIER_BIT_EXT: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_PIXEL_BUFFER_BARRIER_BIT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_PIXEL_BUFFER_BARRIER_BIT_EXT: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_TEXTURE_UPDATE_BARRIER_BIT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_TEXTURE_UPDATE_BARRIER_BIT_EXT: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_BUFFER_UPDATE_BARRIER_BIT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_BUFFER_UPDATE_BARRIER_BIT_EXT: boolean read self.val and $0200 <> 0;
public property HAS_FLAG_FRAMEBUFFER_BARRIER_BIT: boolean read self.val and $0400 <> 0;
public property HAS_FLAG_FRAMEBUFFER_BARRIER_BIT_EXT: boolean read self.val and $0400 <> 0;
public property HAS_FLAG_TRANSFORM_FEEDBACK_BARRIER_BIT: boolean read self.val and $0800 <> 0;
public property HAS_FLAG_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT: boolean read self.val and $0800 <> 0;
public property HAS_FLAG_ATOMIC_COUNTER_BARRIER_BIT: boolean read self.val and $1000 <> 0;
public property HAS_FLAG_ATOMIC_COUNTER_BARRIER_BIT_EXT: boolean read self.val and $1000 <> 0;
public property HAS_FLAG_SHADER_STORAGE_BARRIER_BIT: boolean read self.val and $2000 <> 0;
public property HAS_FLAG_CLIENT_MAPPED_BUFFER_BARRIER_BIT: boolean read self.val and $4000 <> 0;
public property HAS_FLAG_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT: boolean read self.val and $4000 <> 0;
public property HAS_FLAG_QUERY_BUFFER_BARRIER_BIT: boolean read self.val and $8000 <> 0;
public property HAS_FLAG_ALL_BARRIER_BITS: boolean read self.val and $FFFFFFFF <> 0;
public property HAS_FLAG_ALL_BARRIER_BITS_EXT: boolean read self.val and $FFFFFFFF <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'VERTEX_ATTRIB_ARRAY_BARRIER_BIT+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'ELEMENT_ARRAY_BARRIER_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'ELEMENT_ARRAY_BARRIER_BIT_EXT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'UNIFORM_BARRIER_BIT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'UNIFORM_BARRIER_BIT_EXT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'TEXTURE_FETCH_BARRIER_BIT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'TEXTURE_FETCH_BARRIER_BIT_EXT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'SHADER_IMAGE_ACCESS_BARRIER_BIT+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'COMMAND_BARRIER_BIT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'COMMAND_BARRIER_BIT_EXT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'PIXEL_BUFFER_BARRIER_BIT+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'PIXEL_BUFFER_BARRIER_BIT_EXT+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'TEXTURE_UPDATE_BARRIER_BIT+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'TEXTURE_UPDATE_BARRIER_BIT_EXT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'BUFFER_UPDATE_BARRIER_BIT+';
if self.val and UInt32($0200) = UInt32($0200) then res += 'BUFFER_UPDATE_BARRIER_BIT_EXT+';
if self.val and UInt32($0400) = UInt32($0400) then res += 'FRAMEBUFFER_BARRIER_BIT+';
if self.val and UInt32($0400) = UInt32($0400) then res += 'FRAMEBUFFER_BARRIER_BIT_EXT+';
if self.val and UInt32($0800) = UInt32($0800) then res += 'TRANSFORM_FEEDBACK_BARRIER_BIT+';
if self.val and UInt32($0800) = UInt32($0800) then res += 'TRANSFORM_FEEDBACK_BARRIER_BIT_EXT+';
if self.val and UInt32($1000) = UInt32($1000) then res += 'ATOMIC_COUNTER_BARRIER_BIT+';
if self.val and UInt32($1000) = UInt32($1000) then res += 'ATOMIC_COUNTER_BARRIER_BIT_EXT+';
if self.val and UInt32($2000) = UInt32($2000) then res += 'SHADER_STORAGE_BARRIER_BIT+';
if self.val and UInt32($4000) = UInt32($4000) then res += 'CLIENT_MAPPED_BUFFER_BARRIER_BIT+';
if self.val and UInt32($4000) = UInt32($4000) then res += 'CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT+';
if self.val and UInt32($8000) = UInt32($8000) then res += 'QUERY_BUFFER_BARRIER_BIT+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'ALL_BARRIER_BITS+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'ALL_BARRIER_BITS_EXT+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
MemoryObjectParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DEDICATED_MEMORY_OBJECT_EXT := new MemoryObjectParameterName($9581);
private static _PROTECTED_MEMORY_OBJECT_EXT := new MemoryObjectParameterName($959B);
public static property DEDICATED_MEMORY_OBJECT_EXT: MemoryObjectParameterName read _DEDICATED_MEMORY_OBJECT_EXT;
public static property PROTECTED_MEMORY_OBJECT_EXT: MemoryObjectParameterName read _PROTECTED_MEMORY_OBJECT_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($9581) then Result := 'DEDICATED_MEMORY_OBJECT_EXT' else
if self.val = UInt32($959B) then Result := 'PROTECTED_MEMORY_OBJECT_EXT' else
Result := self.val.ToString;
end;
end;
MeshMode1 = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINT := new MeshMode1($1B00);
private static _LINE := new MeshMode1($1B01);
public static property POINT: MeshMode1 read _POINT;
public static property LINE: MeshMode1 read _LINE;
public function ToString: string; override;
begin
if self.val = UInt32($1B00) then Result := 'POINT' else
if self.val = UInt32($1B01) then Result := 'LINE' else
Result := self.val.ToString;
end;
end;
MeshMode2 = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINT := new MeshMode2($1B00);
private static _LINE := new MeshMode2($1B01);
private static _FILL := new MeshMode2($1B02);
public static property POINT: MeshMode2 read _POINT;
public static property LINE: MeshMode2 read _LINE;
public static property FILL: MeshMode2 read _FILL;
public function ToString: string; override;
begin
if self.val = UInt32($1B00) then Result := 'POINT' else
if self.val = UInt32($1B01) then Result := 'LINE' else
if self.val = UInt32($1B02) then Result := 'FILL' else
Result := self.val.ToString;
end;
end;
NormalPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new NormalPointerType($1400);
private static _SHORT := new NormalPointerType($1402);
private static _INT := new NormalPointerType($1404);
private static _FLOAT := new NormalPointerType($1406);
private static _DOUBLE := new NormalPointerType($140A);
public static property BYTE: NormalPointerType read _BYTE;
public static property SHORT: NormalPointerType read _SHORT;
public static property INT: NormalPointerType read _INT;
public static property FLOAT: NormalPointerType read _FLOAT;
public static property DOUBLE: NormalPointerType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
ObjectIdentifier = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE := new ObjectIdentifier($1702);
private static _VERTEX_ARRAY := new ObjectIdentifier($8074);
private static _BUFFER := new ObjectIdentifier($82E0);
private static _SHADER := new ObjectIdentifier($82E1);
private static _PROGRAM := new ObjectIdentifier($82E2);
private static _QUERY := new ObjectIdentifier($82E3);
private static _PROGRAM_PIPELINE := new ObjectIdentifier($82E4);
private static _SAMPLER := new ObjectIdentifier($82E6);
private static _FRAMEBUFFER := new ObjectIdentifier($8D40);
private static _RENDERBUFFER := new ObjectIdentifier($8D41);
private static _TRANSFORM_FEEDBACK := new ObjectIdentifier($8E22);
public static property TEXTURE: ObjectIdentifier read _TEXTURE;
public static property VERTEX_ARRAY: ObjectIdentifier read _VERTEX_ARRAY;
public static property BUFFER: ObjectIdentifier read _BUFFER;
public static property SHADER: ObjectIdentifier read _SHADER;
public static property &PROGRAM: ObjectIdentifier read _PROGRAM;
public static property QUERY: ObjectIdentifier read _QUERY;
public static property PROGRAM_PIPELINE: ObjectIdentifier read _PROGRAM_PIPELINE;
public static property SAMPLER: ObjectIdentifier read _SAMPLER;
public static property FRAMEBUFFER: ObjectIdentifier read _FRAMEBUFFER;
public static property RENDERBUFFER: ObjectIdentifier read _RENDERBUFFER;
public static property TRANSFORM_FEEDBACK: ObjectIdentifier read _TRANSFORM_FEEDBACK;
public function ToString: string; override;
begin
if self.val = UInt32($1702) then Result := 'TEXTURE' else
if self.val = UInt32($8074) then Result := 'VERTEX_ARRAY' else
if self.val = UInt32($82E0) then Result := 'BUFFER' else
if self.val = UInt32($82E1) then Result := 'SHADER' else
if self.val = UInt32($82E2) then Result := 'PROGRAM' else
if self.val = UInt32($82E3) then Result := 'QUERY' else
if self.val = UInt32($82E4) then Result := 'PROGRAM_PIPELINE' else
if self.val = UInt32($82E6) then Result := 'SAMPLER' else
if self.val = UInt32($8D40) then Result := 'FRAMEBUFFER' else
if self.val = UInt32($8D41) then Result := 'RENDERBUFFER' else
if self.val = UInt32($8E22) then Result := 'TRANSFORM_FEEDBACK' else
Result := self.val.ToString;
end;
end;
PatchParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PATCH_VERTICES := new PatchParameterName($8E72);
private static _PATCH_DEFAULT_INNER_LEVEL := new PatchParameterName($8E73);
private static _PATCH_DEFAULT_OUTER_LEVEL := new PatchParameterName($8E74);
public static property PATCH_VERTICES: PatchParameterName read _PATCH_VERTICES;
public static property PATCH_DEFAULT_INNER_LEVEL: PatchParameterName read _PATCH_DEFAULT_INNER_LEVEL;
public static property PATCH_DEFAULT_OUTER_LEVEL: PatchParameterName read _PATCH_DEFAULT_OUTER_LEVEL;
public function ToString: string; override;
begin
if self.val = UInt32($8E72) then Result := 'PATCH_VERTICES' else
if self.val = UInt32($8E73) then Result := 'PATCH_DEFAULT_INNER_LEVEL' else
if self.val = UInt32($8E74) then Result := 'PATCH_DEFAULT_OUTER_LEVEL' else
Result := self.val.ToString;
end;
end;
PathColor = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PRIMARY_COLOR_NV := new PathColor($852C);
private static _SECONDARY_COLOR_NV := new PathColor($852D);
private static _PRIMARY_COLOR := new PathColor($8577);
public static property PRIMARY_COLOR_NV: PathColor read _PRIMARY_COLOR_NV;
public static property SECONDARY_COLOR_NV: PathColor read _SECONDARY_COLOR_NV;
public static property PRIMARY_COLOR: PathColor read _PRIMARY_COLOR;
public function ToString: string; override;
begin
if self.val = UInt32($852C) then Result := 'PRIMARY_COLOR_NV' else
if self.val = UInt32($852D) then Result := 'SECONDARY_COLOR_NV' else
if self.val = UInt32($8577) then Result := 'PRIMARY_COLOR' else
Result := self.val.ToString;
end;
end;
PathColorFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new PathColorFormat($0000);
private static _ALPHA := new PathColorFormat($1906);
private static _RGB := new PathColorFormat($1907);
private static _RGBA := new PathColorFormat($1908);
private static _LUMINANCE := new PathColorFormat($1909);
private static _LUMINANCE_ALPHA := new PathColorFormat($190A);
private static _INTENSITY := new PathColorFormat($8049);
public static property NONE: PathColorFormat read _NONE;
public static property ALPHA: PathColorFormat read _ALPHA;
public static property RGB: PathColorFormat read _RGB;
public static property RGBA: PathColorFormat read _RGBA;
public static property LUMINANCE: PathColorFormat read _LUMINANCE;
public static property LUMINANCE_ALPHA: PathColorFormat read _LUMINANCE_ALPHA;
public static property INTENSITY: PathColorFormat read _INTENSITY;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($1906) then Result := 'ALPHA' else
if self.val = UInt32($1907) then Result := 'RGB' else
if self.val = UInt32($1908) then Result := 'RGBA' else
if self.val = UInt32($1909) then Result := 'LUMINANCE' else
if self.val = UInt32($190A) then Result := 'LUMINANCE_ALPHA' else
if self.val = UInt32($8049) then Result := 'INTENSITY' else
Result := self.val.ToString;
end;
end;
PathCoordType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CLOSE_PATH_NV := new PathCoordType($0000);
private static _MOVE_TO_NV := new PathCoordType($0002);
private static _RELATIVE_MOVE_TO_NV := new PathCoordType($0003);
private static _LINE_TO_NV := new PathCoordType($0004);
private static _RELATIVE_LINE_TO_NV := new PathCoordType($0005);
private static _HORIZONTAL_LINE_TO_NV := new PathCoordType($0006);
private static _RELATIVE_HORIZONTAL_LINE_TO_NV := new PathCoordType($0007);
private static _VERTICAL_LINE_TO_NV := new PathCoordType($0008);
private static _RELATIVE_VERTICAL_LINE_TO_NV := new PathCoordType($0009);
private static _QUADRATIC_CURVE_TO_NV := new PathCoordType($000A);
private static _RELATIVE_QUADRATIC_CURVE_TO_NV := new PathCoordType($000B);
private static _CUBIC_CURVE_TO_NV := new PathCoordType($000C);
private static _RELATIVE_CUBIC_CURVE_TO_NV := new PathCoordType($000D);
private static _SMOOTH_QUADRATIC_CURVE_TO_NV := new PathCoordType($000E);
private static _RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV := new PathCoordType($000F);
private static _SMOOTH_CUBIC_CURVE_TO_NV := new PathCoordType($0010);
private static _RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV := new PathCoordType($0011);
private static _SMALL_CCW_ARC_TO_NV := new PathCoordType($0012);
private static _RELATIVE_SMALL_CCW_ARC_TO_NV := new PathCoordType($0013);
private static _SMALL_CW_ARC_TO_NV := new PathCoordType($0014);
private static _RELATIVE_SMALL_CW_ARC_TO_NV := new PathCoordType($0015);
private static _LARGE_CCW_ARC_TO_NV := new PathCoordType($0016);
private static _RELATIVE_LARGE_CCW_ARC_TO_NV := new PathCoordType($0017);
private static _LARGE_CW_ARC_TO_NV := new PathCoordType($0018);
private static _RELATIVE_LARGE_CW_ARC_TO_NV := new PathCoordType($0019);
private static _CONIC_CURVE_TO_NV := new PathCoordType($001A);
private static _RELATIVE_CONIC_CURVE_TO_NV := new PathCoordType($001B);
private static _ROUNDED_RECT_NV := new PathCoordType($00E8);
private static _RELATIVE_ROUNDED_RECT_NV := new PathCoordType($00E9);
private static _ROUNDED_RECT2_NV := new PathCoordType($00EA);
private static _RELATIVE_ROUNDED_RECT2_NV := new PathCoordType($00EB);
private static _ROUNDED_RECT4_NV := new PathCoordType($00EC);
private static _RELATIVE_ROUNDED_RECT4_NV := new PathCoordType($00ED);
private static _ROUNDED_RECT8_NV := new PathCoordType($00EE);
private static _RELATIVE_ROUNDED_RECT8_NV := new PathCoordType($00EF);
private static _RESTART_PATH_NV := new PathCoordType($00F0);
private static _DUP_FIRST_CUBIC_CURVE_TO_NV := new PathCoordType($00F2);
private static _DUP_LAST_CUBIC_CURVE_TO_NV := new PathCoordType($00F4);
private static _RECT_NV := new PathCoordType($00F6);
private static _RELATIVE_RECT_NV := new PathCoordType($00F7);
private static _CIRCULAR_CCW_ARC_TO_NV := new PathCoordType($00F8);
private static _CIRCULAR_CW_ARC_TO_NV := new PathCoordType($00FA);
private static _CIRCULAR_TANGENT_ARC_TO_NV := new PathCoordType($00FC);
private static _ARC_TO_NV := new PathCoordType($00FE);
private static _RELATIVE_ARC_TO_NV := new PathCoordType($00FF);
public static property CLOSE_PATH_NV: PathCoordType read _CLOSE_PATH_NV;
public static property MOVE_TO_NV: PathCoordType read _MOVE_TO_NV;
public static property RELATIVE_MOVE_TO_NV: PathCoordType read _RELATIVE_MOVE_TO_NV;
public static property LINE_TO_NV: PathCoordType read _LINE_TO_NV;
public static property RELATIVE_LINE_TO_NV: PathCoordType read _RELATIVE_LINE_TO_NV;
public static property HORIZONTAL_LINE_TO_NV: PathCoordType read _HORIZONTAL_LINE_TO_NV;
public static property RELATIVE_HORIZONTAL_LINE_TO_NV: PathCoordType read _RELATIVE_HORIZONTAL_LINE_TO_NV;
public static property VERTICAL_LINE_TO_NV: PathCoordType read _VERTICAL_LINE_TO_NV;
public static property RELATIVE_VERTICAL_LINE_TO_NV: PathCoordType read _RELATIVE_VERTICAL_LINE_TO_NV;
public static property QUADRATIC_CURVE_TO_NV: PathCoordType read _QUADRATIC_CURVE_TO_NV;
public static property RELATIVE_QUADRATIC_CURVE_TO_NV: PathCoordType read _RELATIVE_QUADRATIC_CURVE_TO_NV;
public static property CUBIC_CURVE_TO_NV: PathCoordType read _CUBIC_CURVE_TO_NV;
public static property RELATIVE_CUBIC_CURVE_TO_NV: PathCoordType read _RELATIVE_CUBIC_CURVE_TO_NV;
public static property SMOOTH_QUADRATIC_CURVE_TO_NV: PathCoordType read _SMOOTH_QUADRATIC_CURVE_TO_NV;
public static property RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV: PathCoordType read _RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV;
public static property SMOOTH_CUBIC_CURVE_TO_NV: PathCoordType read _SMOOTH_CUBIC_CURVE_TO_NV;
public static property RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV: PathCoordType read _RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV;
public static property SMALL_CCW_ARC_TO_NV: PathCoordType read _SMALL_CCW_ARC_TO_NV;
public static property RELATIVE_SMALL_CCW_ARC_TO_NV: PathCoordType read _RELATIVE_SMALL_CCW_ARC_TO_NV;
public static property SMALL_CW_ARC_TO_NV: PathCoordType read _SMALL_CW_ARC_TO_NV;
public static property RELATIVE_SMALL_CW_ARC_TO_NV: PathCoordType read _RELATIVE_SMALL_CW_ARC_TO_NV;
public static property LARGE_CCW_ARC_TO_NV: PathCoordType read _LARGE_CCW_ARC_TO_NV;
public static property RELATIVE_LARGE_CCW_ARC_TO_NV: PathCoordType read _RELATIVE_LARGE_CCW_ARC_TO_NV;
public static property LARGE_CW_ARC_TO_NV: PathCoordType read _LARGE_CW_ARC_TO_NV;
public static property RELATIVE_LARGE_CW_ARC_TO_NV: PathCoordType read _RELATIVE_LARGE_CW_ARC_TO_NV;
public static property CONIC_CURVE_TO_NV: PathCoordType read _CONIC_CURVE_TO_NV;
public static property RELATIVE_CONIC_CURVE_TO_NV: PathCoordType read _RELATIVE_CONIC_CURVE_TO_NV;
public static property ROUNDED_RECT_NV: PathCoordType read _ROUNDED_RECT_NV;
public static property RELATIVE_ROUNDED_RECT_NV: PathCoordType read _RELATIVE_ROUNDED_RECT_NV;
public static property ROUNDED_RECT2_NV: PathCoordType read _ROUNDED_RECT2_NV;
public static property RELATIVE_ROUNDED_RECT2_NV: PathCoordType read _RELATIVE_ROUNDED_RECT2_NV;
public static property ROUNDED_RECT4_NV: PathCoordType read _ROUNDED_RECT4_NV;
public static property RELATIVE_ROUNDED_RECT4_NV: PathCoordType read _RELATIVE_ROUNDED_RECT4_NV;
public static property ROUNDED_RECT8_NV: PathCoordType read _ROUNDED_RECT8_NV;
public static property RELATIVE_ROUNDED_RECT8_NV: PathCoordType read _RELATIVE_ROUNDED_RECT8_NV;
public static property RESTART_PATH_NV: PathCoordType read _RESTART_PATH_NV;
public static property DUP_FIRST_CUBIC_CURVE_TO_NV: PathCoordType read _DUP_FIRST_CUBIC_CURVE_TO_NV;
public static property DUP_LAST_CUBIC_CURVE_TO_NV: PathCoordType read _DUP_LAST_CUBIC_CURVE_TO_NV;
public static property RECT_NV: PathCoordType read _RECT_NV;
public static property RELATIVE_RECT_NV: PathCoordType read _RELATIVE_RECT_NV;
public static property CIRCULAR_CCW_ARC_TO_NV: PathCoordType read _CIRCULAR_CCW_ARC_TO_NV;
public static property CIRCULAR_CW_ARC_TO_NV: PathCoordType read _CIRCULAR_CW_ARC_TO_NV;
public static property CIRCULAR_TANGENT_ARC_TO_NV: PathCoordType read _CIRCULAR_TANGENT_ARC_TO_NV;
public static property ARC_TO_NV: PathCoordType read _ARC_TO_NV;
public static property RELATIVE_ARC_TO_NV: PathCoordType read _RELATIVE_ARC_TO_NV;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'CLOSE_PATH_NV' else
if self.val = UInt32($0002) then Result := 'MOVE_TO_NV' else
if self.val = UInt32($0003) then Result := 'RELATIVE_MOVE_TO_NV' else
if self.val = UInt32($0004) then Result := 'LINE_TO_NV' else
if self.val = UInt32($0005) then Result := 'RELATIVE_LINE_TO_NV' else
if self.val = UInt32($0006) then Result := 'HORIZONTAL_LINE_TO_NV' else
if self.val = UInt32($0007) then Result := 'RELATIVE_HORIZONTAL_LINE_TO_NV' else
if self.val = UInt32($0008) then Result := 'VERTICAL_LINE_TO_NV' else
if self.val = UInt32($0009) then Result := 'RELATIVE_VERTICAL_LINE_TO_NV' else
if self.val = UInt32($000A) then Result := 'QUADRATIC_CURVE_TO_NV' else
if self.val = UInt32($000B) then Result := 'RELATIVE_QUADRATIC_CURVE_TO_NV' else
if self.val = UInt32($000C) then Result := 'CUBIC_CURVE_TO_NV' else
if self.val = UInt32($000D) then Result := 'RELATIVE_CUBIC_CURVE_TO_NV' else
if self.val = UInt32($000E) then Result := 'SMOOTH_QUADRATIC_CURVE_TO_NV' else
if self.val = UInt32($000F) then Result := 'RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV' else
if self.val = UInt32($0010) then Result := 'SMOOTH_CUBIC_CURVE_TO_NV' else
if self.val = UInt32($0011) then Result := 'RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV' else
if self.val = UInt32($0012) then Result := 'SMALL_CCW_ARC_TO_NV' else
if self.val = UInt32($0013) then Result := 'RELATIVE_SMALL_CCW_ARC_TO_NV' else
if self.val = UInt32($0014) then Result := 'SMALL_CW_ARC_TO_NV' else
if self.val = UInt32($0015) then Result := 'RELATIVE_SMALL_CW_ARC_TO_NV' else
if self.val = UInt32($0016) then Result := 'LARGE_CCW_ARC_TO_NV' else
if self.val = UInt32($0017) then Result := 'RELATIVE_LARGE_CCW_ARC_TO_NV' else
if self.val = UInt32($0018) then Result := 'LARGE_CW_ARC_TO_NV' else
if self.val = UInt32($0019) then Result := 'RELATIVE_LARGE_CW_ARC_TO_NV' else
if self.val = UInt32($001A) then Result := 'CONIC_CURVE_TO_NV' else
if self.val = UInt32($001B) then Result := 'RELATIVE_CONIC_CURVE_TO_NV' else
if self.val = UInt32($00E8) then Result := 'ROUNDED_RECT_NV' else
if self.val = UInt32($00E9) then Result := 'RELATIVE_ROUNDED_RECT_NV' else
if self.val = UInt32($00EA) then Result := 'ROUNDED_RECT2_NV' else
if self.val = UInt32($00EB) then Result := 'RELATIVE_ROUNDED_RECT2_NV' else
if self.val = UInt32($00EC) then Result := 'ROUNDED_RECT4_NV' else
if self.val = UInt32($00ED) then Result := 'RELATIVE_ROUNDED_RECT4_NV' else
if self.val = UInt32($00EE) then Result := 'ROUNDED_RECT8_NV' else
if self.val = UInt32($00EF) then Result := 'RELATIVE_ROUNDED_RECT8_NV' else
if self.val = UInt32($00F0) then Result := 'RESTART_PATH_NV' else
if self.val = UInt32($00F2) then Result := 'DUP_FIRST_CUBIC_CURVE_TO_NV' else
if self.val = UInt32($00F4) then Result := 'DUP_LAST_CUBIC_CURVE_TO_NV' else
if self.val = UInt32($00F6) then Result := 'RECT_NV' else
if self.val = UInt32($00F7) then Result := 'RELATIVE_RECT_NV' else
if self.val = UInt32($00F8) then Result := 'CIRCULAR_CCW_ARC_TO_NV' else
if self.val = UInt32($00FA) then Result := 'CIRCULAR_CW_ARC_TO_NV' else
if self.val = UInt32($00FC) then Result := 'CIRCULAR_TANGENT_ARC_TO_NV' else
if self.val = UInt32($00FE) then Result := 'ARC_TO_NV' else
if self.val = UInt32($00FF) then Result := 'RELATIVE_ARC_TO_NV' else
Result := self.val.ToString;
end;
end;
PathCoverMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PATH_FILL_COVER_MODE_NV := new PathCoverMode($9082);
private static _CONVEX_HULL_NV := new PathCoverMode($908B);
private static _BOUNDING_BOX_NV := new PathCoverMode($908D);
private static _BOUNDING_BOX_OF_BOUNDING_BOXES_NV := new PathCoverMode($909C);
public static property PATH_FILL_COVER_MODE_NV: PathCoverMode read _PATH_FILL_COVER_MODE_NV;
public static property CONVEX_HULL_NV: PathCoverMode read _CONVEX_HULL_NV;
public static property BOUNDING_BOX_NV: PathCoverMode read _BOUNDING_BOX_NV;
public static property BOUNDING_BOX_OF_BOUNDING_BOXES_NV: PathCoverMode read _BOUNDING_BOX_OF_BOUNDING_BOXES_NV;
public function ToString: string; override;
begin
if self.val = UInt32($9082) then Result := 'PATH_FILL_COVER_MODE_NV' else
if self.val = UInt32($908B) then Result := 'CONVEX_HULL_NV' else
if self.val = UInt32($908D) then Result := 'BOUNDING_BOX_NV' else
if self.val = UInt32($909C) then Result := 'BOUNDING_BOX_OF_BOUNDING_BOXES_NV' else
Result := self.val.ToString;
end;
end;
PathElementType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UTF8_NV := new PathElementType($909A);
private static _UTF16_NV := new PathElementType($909B);
public static property UTF8_NV: PathElementType read _UTF8_NV;
public static property UTF16_NV: PathElementType read _UTF16_NV;
public function ToString: string; override;
begin
if self.val = UInt32($909A) then Result := 'UTF8_NV' else
if self.val = UInt32($909B) then Result := 'UTF16_NV' else
Result := self.val.ToString;
end;
end;
PathFillMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INVERT := new PathFillMode($150A);
private static _PATH_FILL_MODE_NV := new PathFillMode($9080);
private static _COUNT_UP_NV := new PathFillMode($9088);
private static _COUNT_DOWN_NV := new PathFillMode($9089);
public static property INVERT: PathFillMode read _INVERT;
public static property PATH_FILL_MODE_NV: PathFillMode read _PATH_FILL_MODE_NV;
public static property COUNT_UP_NV: PathFillMode read _COUNT_UP_NV;
public static property COUNT_DOWN_NV: PathFillMode read _COUNT_DOWN_NV;
public function ToString: string; override;
begin
if self.val = UInt32($150A) then Result := 'INVERT' else
if self.val = UInt32($9080) then Result := 'PATH_FILL_MODE_NV' else
if self.val = UInt32($9088) then Result := 'COUNT_UP_NV' else
if self.val = UInt32($9089) then Result := 'COUNT_DOWN_NV' else
Result := self.val.ToString;
end;
end;
PathFontStyle = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new PathFontStyle($0000);
private static _BOLD_BIT_NV := new PathFontStyle($0001);
private static _ITALIC_BIT_NV := new PathFontStyle($0002);
public static property NONE: PathFontStyle read _NONE;
public static property BOLD_BIT_NV: PathFontStyle read _BOLD_BIT_NV;
public static property ITALIC_BIT_NV: PathFontStyle read _ITALIC_BIT_NV;
public static function operator or(f1,f2: PathFontStyle) := new PathFontStyle(f1.val or f2.val);
public property ANY_FLAGS: boolean read self.val<>0;
public property HAS_FLAG_BOLD_BIT_NV: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_ITALIC_BIT_NV: boolean read self.val and $0002 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0000) = UInt32($0000) then res += 'NONE+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'BOLD_BIT_NV+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'ITALIC_BIT_NV+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
PathFontTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STANDARD_FONT_NAME_NV := new PathFontTarget($9072);
private static _SYSTEM_FONT_NAME_NV := new PathFontTarget($9073);
private static _FILE_NAME_NV := new PathFontTarget($9074);
public static property STANDARD_FONT_NAME_NV: PathFontTarget read _STANDARD_FONT_NAME_NV;
public static property SYSTEM_FONT_NAME_NV: PathFontTarget read _SYSTEM_FONT_NAME_NV;
public static property FILE_NAME_NV: PathFontTarget read _FILE_NAME_NV;
public function ToString: string; override;
begin
if self.val = UInt32($9072) then Result := 'STANDARD_FONT_NAME_NV' else
if self.val = UInt32($9073) then Result := 'SYSTEM_FONT_NAME_NV' else
if self.val = UInt32($9074) then Result := 'FILE_NAME_NV' else
Result := self.val.ToString;
end;
end;
PathGenMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new PathGenMode($0000);
private static _EYE_LINEAR := new PathGenMode($2400);
private static _OBJECT_LINEAR := new PathGenMode($2401);
private static _CONSTANT := new PathGenMode($8576);
private static _PATH_OBJECT_BOUNDING_BOX_NV := new PathGenMode($908A);
public static property NONE: PathGenMode read _NONE;
public static property EYE_LINEAR: PathGenMode read _EYE_LINEAR;
public static property OBJECT_LINEAR: PathGenMode read _OBJECT_LINEAR;
public static property CONSTANT: PathGenMode read _CONSTANT;
public static property PATH_OBJECT_BOUNDING_BOX_NV: PathGenMode read _PATH_OBJECT_BOUNDING_BOX_NV;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($2400) then Result := 'EYE_LINEAR' else
if self.val = UInt32($2401) then Result := 'OBJECT_LINEAR' else
if self.val = UInt32($8576) then Result := 'CONSTANT' else
if self.val = UInt32($908A) then Result := 'PATH_OBJECT_BOUNDING_BOX_NV' else
Result := self.val.ToString;
end;
end;
PathHandleMissingGlyphs = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SKIP_MISSING_GLYPH_NV := new PathHandleMissingGlyphs($90A9);
private static _USE_MISSING_GLYPH_NV := new PathHandleMissingGlyphs($90AA);
public static property SKIP_MISSING_GLYPH_NV: PathHandleMissingGlyphs read _SKIP_MISSING_GLYPH_NV;
public static property USE_MISSING_GLYPH_NV: PathHandleMissingGlyphs read _USE_MISSING_GLYPH_NV;
public function ToString: string; override;
begin
if self.val = UInt32($90A9) then Result := 'SKIP_MISSING_GLYPH_NV' else
if self.val = UInt32($90AA) then Result := 'USE_MISSING_GLYPH_NV' else
Result := self.val.ToString;
end;
end;
PathListMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ACCUM_ADJACENT_PAIRS_NV := new PathListMode($90AD);
private static _ADJACENT_PAIRS_NV := new PathListMode($90AE);
private static _FIRST_TO_REST_NV := new PathListMode($90AF);
public static property ACCUM_ADJACENT_PAIRS_NV: PathListMode read _ACCUM_ADJACENT_PAIRS_NV;
public static property ADJACENT_PAIRS_NV: PathListMode read _ADJACENT_PAIRS_NV;
public static property FIRST_TO_REST_NV: PathListMode read _FIRST_TO_REST_NV;
public function ToString: string; override;
begin
if self.val = UInt32($90AD) then Result := 'ACCUM_ADJACENT_PAIRS_NV' else
if self.val = UInt32($90AE) then Result := 'ADJACENT_PAIRS_NV' else
if self.val = UInt32($90AF) then Result := 'FIRST_TO_REST_NV' else
Result := self.val.ToString;
end;
end;
PathMetricMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _GLYPH_WIDTH_BIT_NV := new PathMetricMask($0001);
private static _GLYPH_HEIGHT_BIT_NV := new PathMetricMask($0002);
private static _GLYPH_HORIZONTAL_BEARING_X_BIT_NV := new PathMetricMask($0004);
private static _GLYPH_HORIZONTAL_BEARING_Y_BIT_NV := new PathMetricMask($0008);
private static _GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV := new PathMetricMask($0010);
private static _GLYPH_VERTICAL_BEARING_X_BIT_NV := new PathMetricMask($0020);
private static _GLYPH_VERTICAL_BEARING_Y_BIT_NV := new PathMetricMask($0040);
private static _GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV := new PathMetricMask($0080);
private static _GLYPH_HAS_KERNING_BIT_NV := new PathMetricMask($0100);
private static _FONT_X_MIN_BOUNDS_BIT_NV := new PathMetricMask($10000);
private static _FONT_Y_MIN_BOUNDS_BIT_NV := new PathMetricMask($20000);
private static _FONT_X_MAX_BOUNDS_BIT_NV := new PathMetricMask($40000);
private static _FONT_Y_MAX_BOUNDS_BIT_NV := new PathMetricMask($80000);
private static _FONT_UNITS_PER_EM_BIT_NV := new PathMetricMask($100000);
private static _FONT_ASCENDER_BIT_NV := new PathMetricMask($200000);
private static _FONT_DESCENDER_BIT_NV := new PathMetricMask($400000);
private static _FONT_HEIGHT_BIT_NV := new PathMetricMask($800000);
private static _FONT_MAX_ADVANCE_WIDTH_BIT_NV := new PathMetricMask($1000000);
private static _FONT_MAX_ADVANCE_HEIGHT_BIT_NV := new PathMetricMask($2000000);
private static _FONT_UNDERLINE_POSITION_BIT_NV := new PathMetricMask($4000000);
private static _FONT_UNDERLINE_THICKNESS_BIT_NV := new PathMetricMask($8000000);
private static _FONT_HAS_KERNING_BIT_NV := new PathMetricMask($10000000);
private static _FONT_NUM_GLYPH_INDICES_BIT_NV := new PathMetricMask($20000000);
public static property GLYPH_WIDTH_BIT_NV: PathMetricMask read _GLYPH_WIDTH_BIT_NV;
public static property GLYPH_HEIGHT_BIT_NV: PathMetricMask read _GLYPH_HEIGHT_BIT_NV;
public static property GLYPH_HORIZONTAL_BEARING_X_BIT_NV: PathMetricMask read _GLYPH_HORIZONTAL_BEARING_X_BIT_NV;
public static property GLYPH_HORIZONTAL_BEARING_Y_BIT_NV: PathMetricMask read _GLYPH_HORIZONTAL_BEARING_Y_BIT_NV;
public static property GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV: PathMetricMask read _GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV;
public static property GLYPH_VERTICAL_BEARING_X_BIT_NV: PathMetricMask read _GLYPH_VERTICAL_BEARING_X_BIT_NV;
public static property GLYPH_VERTICAL_BEARING_Y_BIT_NV: PathMetricMask read _GLYPH_VERTICAL_BEARING_Y_BIT_NV;
public static property GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV: PathMetricMask read _GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV;
public static property GLYPH_HAS_KERNING_BIT_NV: PathMetricMask read _GLYPH_HAS_KERNING_BIT_NV;
public static property FONT_X_MIN_BOUNDS_BIT_NV: PathMetricMask read _FONT_X_MIN_BOUNDS_BIT_NV;
public static property FONT_Y_MIN_BOUNDS_BIT_NV: PathMetricMask read _FONT_Y_MIN_BOUNDS_BIT_NV;
public static property FONT_X_MAX_BOUNDS_BIT_NV: PathMetricMask read _FONT_X_MAX_BOUNDS_BIT_NV;
public static property FONT_Y_MAX_BOUNDS_BIT_NV: PathMetricMask read _FONT_Y_MAX_BOUNDS_BIT_NV;
public static property FONT_UNITS_PER_EM_BIT_NV: PathMetricMask read _FONT_UNITS_PER_EM_BIT_NV;
public static property FONT_ASCENDER_BIT_NV: PathMetricMask read _FONT_ASCENDER_BIT_NV;
public static property FONT_DESCENDER_BIT_NV: PathMetricMask read _FONT_DESCENDER_BIT_NV;
public static property FONT_HEIGHT_BIT_NV: PathMetricMask read _FONT_HEIGHT_BIT_NV;
public static property FONT_MAX_ADVANCE_WIDTH_BIT_NV: PathMetricMask read _FONT_MAX_ADVANCE_WIDTH_BIT_NV;
public static property FONT_MAX_ADVANCE_HEIGHT_BIT_NV: PathMetricMask read _FONT_MAX_ADVANCE_HEIGHT_BIT_NV;
public static property FONT_UNDERLINE_POSITION_BIT_NV: PathMetricMask read _FONT_UNDERLINE_POSITION_BIT_NV;
public static property FONT_UNDERLINE_THICKNESS_BIT_NV: PathMetricMask read _FONT_UNDERLINE_THICKNESS_BIT_NV;
public static property FONT_HAS_KERNING_BIT_NV: PathMetricMask read _FONT_HAS_KERNING_BIT_NV;
public static property FONT_NUM_GLYPH_INDICES_BIT_NV: PathMetricMask read _FONT_NUM_GLYPH_INDICES_BIT_NV;
public static function operator or(f1,f2: PathMetricMask) := new PathMetricMask(f1.val or f2.val);
public property HAS_FLAG_GLYPH_WIDTH_BIT_NV: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_GLYPH_HEIGHT_BIT_NV: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_GLYPH_HORIZONTAL_BEARING_X_BIT_NV: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_GLYPH_VERTICAL_BEARING_X_BIT_NV: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_GLYPH_VERTICAL_BEARING_Y_BIT_NV: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_GLYPH_HAS_KERNING_BIT_NV: boolean read self.val and $0100 <> 0;
public property HAS_FLAG_FONT_X_MIN_BOUNDS_BIT_NV: boolean read self.val and $10000 <> 0;
public property HAS_FLAG_FONT_Y_MIN_BOUNDS_BIT_NV: boolean read self.val and $20000 <> 0;
public property HAS_FLAG_FONT_X_MAX_BOUNDS_BIT_NV: boolean read self.val and $40000 <> 0;
public property HAS_FLAG_FONT_Y_MAX_BOUNDS_BIT_NV: boolean read self.val and $80000 <> 0;
public property HAS_FLAG_FONT_UNITS_PER_EM_BIT_NV: boolean read self.val and $100000 <> 0;
public property HAS_FLAG_FONT_ASCENDER_BIT_NV: boolean read self.val and $200000 <> 0;
public property HAS_FLAG_FONT_DESCENDER_BIT_NV: boolean read self.val and $400000 <> 0;
public property HAS_FLAG_FONT_HEIGHT_BIT_NV: boolean read self.val and $800000 <> 0;
public property HAS_FLAG_FONT_MAX_ADVANCE_WIDTH_BIT_NV: boolean read self.val and $1000000 <> 0;
public property HAS_FLAG_FONT_MAX_ADVANCE_HEIGHT_BIT_NV: boolean read self.val and $2000000 <> 0;
public property HAS_FLAG_FONT_UNDERLINE_POSITION_BIT_NV: boolean read self.val and $4000000 <> 0;
public property HAS_FLAG_FONT_UNDERLINE_THICKNESS_BIT_NV: boolean read self.val and $8000000 <> 0;
public property HAS_FLAG_FONT_HAS_KERNING_BIT_NV: boolean read self.val and $10000000 <> 0;
public property HAS_FLAG_FONT_NUM_GLYPH_INDICES_BIT_NV: boolean read self.val and $20000000 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'GLYPH_WIDTH_BIT_NV+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'GLYPH_HEIGHT_BIT_NV+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'GLYPH_HORIZONTAL_BEARING_X_BIT_NV+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'GLYPH_HORIZONTAL_BEARING_Y_BIT_NV+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'GLYPH_VERTICAL_BEARING_X_BIT_NV+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'GLYPH_VERTICAL_BEARING_Y_BIT_NV+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV+';
if self.val and UInt32($0100) = UInt32($0100) then res += 'GLYPH_HAS_KERNING_BIT_NV+';
if self.val and UInt32($10000) = UInt32($10000) then res += 'FONT_X_MIN_BOUNDS_BIT_NV+';
if self.val and UInt32($20000) = UInt32($20000) then res += 'FONT_Y_MIN_BOUNDS_BIT_NV+';
if self.val and UInt32($40000) = UInt32($40000) then res += 'FONT_X_MAX_BOUNDS_BIT_NV+';
if self.val and UInt32($80000) = UInt32($80000) then res += 'FONT_Y_MAX_BOUNDS_BIT_NV+';
if self.val and UInt32($100000) = UInt32($100000) then res += 'FONT_UNITS_PER_EM_BIT_NV+';
if self.val and UInt32($200000) = UInt32($200000) then res += 'FONT_ASCENDER_BIT_NV+';
if self.val and UInt32($400000) = UInt32($400000) then res += 'FONT_DESCENDER_BIT_NV+';
if self.val and UInt32($800000) = UInt32($800000) then res += 'FONT_HEIGHT_BIT_NV+';
if self.val and UInt32($1000000) = UInt32($1000000) then res += 'FONT_MAX_ADVANCE_WIDTH_BIT_NV+';
if self.val and UInt32($2000000) = UInt32($2000000) then res += 'FONT_MAX_ADVANCE_HEIGHT_BIT_NV+';
if self.val and UInt32($4000000) = UInt32($4000000) then res += 'FONT_UNDERLINE_POSITION_BIT_NV+';
if self.val and UInt32($8000000) = UInt32($8000000) then res += 'FONT_UNDERLINE_THICKNESS_BIT_NV+';
if self.val and UInt32($10000000) = UInt32($10000000) then res += 'FONT_HAS_KERNING_BIT_NV+';
if self.val and UInt32($20000000) = UInt32($20000000) then res += 'FONT_NUM_GLYPH_INDICES_BIT_NV+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
PathParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PATH_STROKE_WIDTH_NV := new PathParameter($9075);
private static _PATH_END_CAPS_NV := new PathParameter($9076);
private static _PATH_INITIAL_END_CAP_NV := new PathParameter($9077);
private static _PATH_TERMINAL_END_CAP_NV := new PathParameter($9078);
private static _PATH_JOIN_STYLE_NV := new PathParameter($9079);
private static _PATH_MITER_LIMIT_NV := new PathParameter($907A);
private static _PATH_DASH_CAPS_NV := new PathParameter($907B);
private static _PATH_INITIAL_DASH_CAP_NV := new PathParameter($907C);
private static _PATH_TERMINAL_DASH_CAP_NV := new PathParameter($907D);
private static _PATH_DASH_OFFSET_NV := new PathParameter($907E);
private static _PATH_CLIENT_LENGTH_NV := new PathParameter($907F);
private static _PATH_FILL_MODE_NV := new PathParameter($9080);
private static _PATH_FILL_MASK_NV := new PathParameter($9081);
private static _PATH_FILL_COVER_MODE_NV := new PathParameter($9082);
private static _PATH_STROKE_COVER_MODE_NV := new PathParameter($9083);
private static _PATH_STROKE_MASK_NV := new PathParameter($9084);
private static _PATH_OBJECT_BOUNDING_BOX_NV := new PathParameter($908A);
private static _PATH_COMMAND_COUNT_NV := new PathParameter($909D);
private static _PATH_COORD_COUNT_NV := new PathParameter($909E);
private static _PATH_DASH_ARRAY_COUNT_NV := new PathParameter($909F);
private static _PATH_COMPUTED_LENGTH_NV := new PathParameter($90A0);
private static _PATH_FILL_BOUNDING_BOX_NV := new PathParameter($90A1);
private static _PATH_STROKE_BOUNDING_BOX_NV := new PathParameter($90A2);
private static _PATH_DASH_OFFSET_RESET_NV := new PathParameter($90B4);
public static property PATH_STROKE_WIDTH_NV: PathParameter read _PATH_STROKE_WIDTH_NV;
public static property PATH_END_CAPS_NV: PathParameter read _PATH_END_CAPS_NV;
public static property PATH_INITIAL_END_CAP_NV: PathParameter read _PATH_INITIAL_END_CAP_NV;
public static property PATH_TERMINAL_END_CAP_NV: PathParameter read _PATH_TERMINAL_END_CAP_NV;
public static property PATH_JOIN_STYLE_NV: PathParameter read _PATH_JOIN_STYLE_NV;
public static property PATH_MITER_LIMIT_NV: PathParameter read _PATH_MITER_LIMIT_NV;
public static property PATH_DASH_CAPS_NV: PathParameter read _PATH_DASH_CAPS_NV;
public static property PATH_INITIAL_DASH_CAP_NV: PathParameter read _PATH_INITIAL_DASH_CAP_NV;
public static property PATH_TERMINAL_DASH_CAP_NV: PathParameter read _PATH_TERMINAL_DASH_CAP_NV;
public static property PATH_DASH_OFFSET_NV: PathParameter read _PATH_DASH_OFFSET_NV;
public static property PATH_CLIENT_LENGTH_NV: PathParameter read _PATH_CLIENT_LENGTH_NV;
public static property PATH_FILL_MODE_NV: PathParameter read _PATH_FILL_MODE_NV;
public static property PATH_FILL_MASK_NV: PathParameter read _PATH_FILL_MASK_NV;
public static property PATH_FILL_COVER_MODE_NV: PathParameter read _PATH_FILL_COVER_MODE_NV;
public static property PATH_STROKE_COVER_MODE_NV: PathParameter read _PATH_STROKE_COVER_MODE_NV;
public static property PATH_STROKE_MASK_NV: PathParameter read _PATH_STROKE_MASK_NV;
public static property PATH_OBJECT_BOUNDING_BOX_NV: PathParameter read _PATH_OBJECT_BOUNDING_BOX_NV;
public static property PATH_COMMAND_COUNT_NV: PathParameter read _PATH_COMMAND_COUNT_NV;
public static property PATH_COORD_COUNT_NV: PathParameter read _PATH_COORD_COUNT_NV;
public static property PATH_DASH_ARRAY_COUNT_NV: PathParameter read _PATH_DASH_ARRAY_COUNT_NV;
public static property PATH_COMPUTED_LENGTH_NV: PathParameter read _PATH_COMPUTED_LENGTH_NV;
public static property PATH_FILL_BOUNDING_BOX_NV: PathParameter read _PATH_FILL_BOUNDING_BOX_NV;
public static property PATH_STROKE_BOUNDING_BOX_NV: PathParameter read _PATH_STROKE_BOUNDING_BOX_NV;
public static property PATH_DASH_OFFSET_RESET_NV: PathParameter read _PATH_DASH_OFFSET_RESET_NV;
public function ToString: string; override;
begin
if self.val = UInt32($9075) then Result := 'PATH_STROKE_WIDTH_NV' else
if self.val = UInt32($9076) then Result := 'PATH_END_CAPS_NV' else
if self.val = UInt32($9077) then Result := 'PATH_INITIAL_END_CAP_NV' else
if self.val = UInt32($9078) then Result := 'PATH_TERMINAL_END_CAP_NV' else
if self.val = UInt32($9079) then Result := 'PATH_JOIN_STYLE_NV' else
if self.val = UInt32($907A) then Result := 'PATH_MITER_LIMIT_NV' else
if self.val = UInt32($907B) then Result := 'PATH_DASH_CAPS_NV' else
if self.val = UInt32($907C) then Result := 'PATH_INITIAL_DASH_CAP_NV' else
if self.val = UInt32($907D) then Result := 'PATH_TERMINAL_DASH_CAP_NV' else
if self.val = UInt32($907E) then Result := 'PATH_DASH_OFFSET_NV' else
if self.val = UInt32($907F) then Result := 'PATH_CLIENT_LENGTH_NV' else
if self.val = UInt32($9080) then Result := 'PATH_FILL_MODE_NV' else
if self.val = UInt32($9081) then Result := 'PATH_FILL_MASK_NV' else
if self.val = UInt32($9082) then Result := 'PATH_FILL_COVER_MODE_NV' else
if self.val = UInt32($9083) then Result := 'PATH_STROKE_COVER_MODE_NV' else
if self.val = UInt32($9084) then Result := 'PATH_STROKE_MASK_NV' else
if self.val = UInt32($908A) then Result := 'PATH_OBJECT_BOUNDING_BOX_NV' else
if self.val = UInt32($909D) then Result := 'PATH_COMMAND_COUNT_NV' else
if self.val = UInt32($909E) then Result := 'PATH_COORD_COUNT_NV' else
if self.val = UInt32($909F) then Result := 'PATH_DASH_ARRAY_COUNT_NV' else
if self.val = UInt32($90A0) then Result := 'PATH_COMPUTED_LENGTH_NV' else
if self.val = UInt32($90A1) then Result := 'PATH_FILL_BOUNDING_BOX_NV' else
if self.val = UInt32($90A2) then Result := 'PATH_STROKE_BOUNDING_BOX_NV' else
if self.val = UInt32($90B4) then Result := 'PATH_DASH_OFFSET_RESET_NV' else
Result := self.val.ToString;
end;
end;
PathStringFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PATH_FORMAT_SVG_NV := new PathStringFormat($9070);
private static _PATH_FORMAT_PS_NV := new PathStringFormat($9071);
public static property PATH_FORMAT_SVG_NV: PathStringFormat read _PATH_FORMAT_SVG_NV;
public static property PATH_FORMAT_PS_NV: PathStringFormat read _PATH_FORMAT_PS_NV;
public function ToString: string; override;
begin
if self.val = UInt32($9070) then Result := 'PATH_FORMAT_SVG_NV' else
if self.val = UInt32($9071) then Result := 'PATH_FORMAT_PS_NV' else
Result := self.val.ToString;
end;
end;
PathTransformType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new PathTransformType($0000);
private static _TRANSLATE_X_NV := new PathTransformType($908E);
private static _TRANSLATE_Y_NV := new PathTransformType($908F);
private static _TRANSLATE_2D_NV := new PathTransformType($9090);
private static _TRANSLATE_3D_NV := new PathTransformType($9091);
private static _AFFINE_2D_NV := new PathTransformType($9092);
private static _AFFINE_3D_NV := new PathTransformType($9094);
private static _TRANSPOSE_AFFINE_2D_NV := new PathTransformType($9096);
private static _TRANSPOSE_AFFINE_3D_NV := new PathTransformType($9098);
public static property NONE: PathTransformType read _NONE;
public static property TRANSLATE_X_NV: PathTransformType read _TRANSLATE_X_NV;
public static property TRANSLATE_Y_NV: PathTransformType read _TRANSLATE_Y_NV;
public static property TRANSLATE_2D_NV: PathTransformType read _TRANSLATE_2D_NV;
public static property TRANSLATE_3D_NV: PathTransformType read _TRANSLATE_3D_NV;
public static property AFFINE_2D_NV: PathTransformType read _AFFINE_2D_NV;
public static property AFFINE_3D_NV: PathTransformType read _AFFINE_3D_NV;
public static property TRANSPOSE_AFFINE_2D_NV: PathTransformType read _TRANSPOSE_AFFINE_2D_NV;
public static property TRANSPOSE_AFFINE_3D_NV: PathTransformType read _TRANSPOSE_AFFINE_3D_NV;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($908E) then Result := 'TRANSLATE_X_NV' else
if self.val = UInt32($908F) then Result := 'TRANSLATE_Y_NV' else
if self.val = UInt32($9090) then Result := 'TRANSLATE_2D_NV' else
if self.val = UInt32($9091) then Result := 'TRANSLATE_3D_NV' else
if self.val = UInt32($9092) then Result := 'AFFINE_2D_NV' else
if self.val = UInt32($9094) then Result := 'AFFINE_3D_NV' else
if self.val = UInt32($9096) then Result := 'TRANSPOSE_AFFINE_2D_NV' else
if self.val = UInt32($9098) then Result := 'TRANSPOSE_AFFINE_3D_NV' else
Result := self.val.ToString;
end;
end;
PipelineParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ACTIVE_PROGRAM := new PipelineParameterName($8259);
private static _FRAGMENT_SHADER := new PipelineParameterName($8B30);
private static _VERTEX_SHADER := new PipelineParameterName($8B31);
private static _INFO_LOG_LENGTH := new PipelineParameterName($8B84);
private static _GEOMETRY_SHADER := new PipelineParameterName($8DD9);
private static _TESS_EVALUATION_SHADER := new PipelineParameterName($8E87);
private static _TESS_CONTROL_SHADER := new PipelineParameterName($8E88);
public static property ACTIVE_PROGRAM: PipelineParameterName read _ACTIVE_PROGRAM;
public static property FRAGMENT_SHADER: PipelineParameterName read _FRAGMENT_SHADER;
public static property VERTEX_SHADER: PipelineParameterName read _VERTEX_SHADER;
public static property INFO_LOG_LENGTH: PipelineParameterName read _INFO_LOG_LENGTH;
public static property GEOMETRY_SHADER: PipelineParameterName read _GEOMETRY_SHADER;
public static property TESS_EVALUATION_SHADER: PipelineParameterName read _TESS_EVALUATION_SHADER;
public static property TESS_CONTROL_SHADER: PipelineParameterName read _TESS_CONTROL_SHADER;
public function ToString: string; override;
begin
if self.val = UInt32($8259) then Result := 'ACTIVE_PROGRAM' else
if self.val = UInt32($8B30) then Result := 'FRAGMENT_SHADER' else
if self.val = UInt32($8B31) then Result := 'VERTEX_SHADER' else
if self.val = UInt32($8B84) then Result := 'INFO_LOG_LENGTH' else
if self.val = UInt32($8DD9) then Result := 'GEOMETRY_SHADER' else
if self.val = UInt32($8E87) then Result := 'TESS_EVALUATION_SHADER' else
if self.val = UInt32($8E88) then Result := 'TESS_CONTROL_SHADER' else
Result := self.val.ToString;
end;
end;
PixelCopyType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR := new PixelCopyType($1800);
private static _COLOR_EXT := new PixelCopyType($1800);
private static _DEPTH := new PixelCopyType($1801);
private static _DEPTH_EXT := new PixelCopyType($1801);
private static _STENCIL := new PixelCopyType($1802);
private static _STENCIL_EXT := new PixelCopyType($1802);
public static property COLOR: PixelCopyType read _COLOR;
public static property COLOR_EXT: PixelCopyType read _COLOR_EXT;
public static property DEPTH: PixelCopyType read _DEPTH;
public static property DEPTH_EXT: PixelCopyType read _DEPTH_EXT;
public static property STENCIL: PixelCopyType read _STENCIL;
public static property STENCIL_EXT: PixelCopyType read _STENCIL_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($1800) then Result := 'COLOR' else
if self.val = UInt32($1800) then Result := 'COLOR_EXT' else
if self.val = UInt32($1801) then Result := 'DEPTH' else
if self.val = UInt32($1801) then Result := 'DEPTH_EXT' else
if self.val = UInt32($1802) then Result := 'STENCIL' else
if self.val = UInt32($1802) then Result := 'STENCIL_EXT' else
Result := self.val.ToString;
end;
end;
PixelFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_SHORT := new PixelFormat($1403);
private static _UNSIGNED_INT := new PixelFormat($1405);
private static _COLOR_INDEX := new PixelFormat($1900);
private static _STENCIL_INDEX := new PixelFormat($1901);
private static _DEPTH_COMPONENT := new PixelFormat($1902);
private static _RED := new PixelFormat($1903);
private static _RED_EXT := new PixelFormat($1903);
private static _GREEN := new PixelFormat($1904);
private static _BLUE := new PixelFormat($1905);
private static _ALPHA := new PixelFormat($1906);
private static _RGB := new PixelFormat($1907);
private static _RGBA := new PixelFormat($1908);
private static _LUMINANCE := new PixelFormat($1909);
private static _LUMINANCE_ALPHA := new PixelFormat($190A);
private static _ABGR_EXT := new PixelFormat($8000);
private static _CMYK_EXT := new PixelFormat($800C);
private static _CMYKA_EXT := new PixelFormat($800D);
private static _BGR := new PixelFormat($80E0);
private static _BGRA := new PixelFormat($80E1);
private static _YCRCB_422_SGIX := new PixelFormat($81BB);
private static _YCRCB_444_SGIX := new PixelFormat($81BC);
private static _RG := new PixelFormat($8227);
private static _RG_INTEGER := new PixelFormat($8228);
private static _DEPTH_STENCIL := new PixelFormat($84F9);
private static _RED_INTEGER := new PixelFormat($8D94);
private static _GREEN_INTEGER := new PixelFormat($8D95);
private static _BLUE_INTEGER := new PixelFormat($8D96);
private static _RGB_INTEGER := new PixelFormat($8D98);
private static _RGBA_INTEGER := new PixelFormat($8D99);
private static _BGR_INTEGER := new PixelFormat($8D9A);
private static _BGRA_INTEGER := new PixelFormat($8D9B);
public static property UNSIGNED_SHORT: PixelFormat read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: PixelFormat read _UNSIGNED_INT;
public static property COLOR_INDEX: PixelFormat read _COLOR_INDEX;
public static property STENCIL_INDEX: PixelFormat read _STENCIL_INDEX;
public static property DEPTH_COMPONENT: PixelFormat read _DEPTH_COMPONENT;
public static property RED: PixelFormat read _RED;
public static property RED_EXT: PixelFormat read _RED_EXT;
public static property GREEN: PixelFormat read _GREEN;
public static property BLUE: PixelFormat read _BLUE;
public static property ALPHA: PixelFormat read _ALPHA;
public static property RGB: PixelFormat read _RGB;
public static property RGBA: PixelFormat read _RGBA;
public static property LUMINANCE: PixelFormat read _LUMINANCE;
public static property LUMINANCE_ALPHA: PixelFormat read _LUMINANCE_ALPHA;
public static property ABGR_EXT: PixelFormat read _ABGR_EXT;
public static property CMYK_EXT: PixelFormat read _CMYK_EXT;
public static property CMYKA_EXT: PixelFormat read _CMYKA_EXT;
public static property BGR: PixelFormat read _BGR;
public static property BGRA: PixelFormat read _BGRA;
public static property YCRCB_422_SGIX: PixelFormat read _YCRCB_422_SGIX;
public static property YCRCB_444_SGIX: PixelFormat read _YCRCB_444_SGIX;
public static property RG: PixelFormat read _RG;
public static property RG_INTEGER: PixelFormat read _RG_INTEGER;
public static property DEPTH_STENCIL: PixelFormat read _DEPTH_STENCIL;
public static property RED_INTEGER: PixelFormat read _RED_INTEGER;
public static property GREEN_INTEGER: PixelFormat read _GREEN_INTEGER;
public static property BLUE_INTEGER: PixelFormat read _BLUE_INTEGER;
public static property RGB_INTEGER: PixelFormat read _RGB_INTEGER;
public static property RGBA_INTEGER: PixelFormat read _RGBA_INTEGER;
public static property BGR_INTEGER: PixelFormat read _BGR_INTEGER;
public static property BGRA_INTEGER: PixelFormat read _BGRA_INTEGER;
public function ToString: string; override;
begin
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1900) then Result := 'COLOR_INDEX' else
if self.val = UInt32($1901) then Result := 'STENCIL_INDEX' else
if self.val = UInt32($1902) then Result := 'DEPTH_COMPONENT' else
if self.val = UInt32($1903) then Result := 'RED' else
if self.val = UInt32($1903) then Result := 'RED_EXT' else
if self.val = UInt32($1904) then Result := 'GREEN' else
if self.val = UInt32($1905) then Result := 'BLUE' else
if self.val = UInt32($1906) then Result := 'ALPHA' else
if self.val = UInt32($1907) then Result := 'RGB' else
if self.val = UInt32($1908) then Result := 'RGBA' else
if self.val = UInt32($1909) then Result := 'LUMINANCE' else
if self.val = UInt32($190A) then Result := 'LUMINANCE_ALPHA' else
if self.val = UInt32($8000) then Result := 'ABGR_EXT' else
if self.val = UInt32($800C) then Result := 'CMYK_EXT' else
if self.val = UInt32($800D) then Result := 'CMYKA_EXT' else
if self.val = UInt32($80E0) then Result := 'BGR' else
if self.val = UInt32($80E1) then Result := 'BGRA' else
if self.val = UInt32($81BB) then Result := 'YCRCB_422_SGIX' else
if self.val = UInt32($81BC) then Result := 'YCRCB_444_SGIX' else
if self.val = UInt32($8227) then Result := 'RG' else
if self.val = UInt32($8228) then Result := 'RG_INTEGER' else
if self.val = UInt32($84F9) then Result := 'DEPTH_STENCIL' else
if self.val = UInt32($8D94) then Result := 'RED_INTEGER' else
if self.val = UInt32($8D95) then Result := 'GREEN_INTEGER' else
if self.val = UInt32($8D96) then Result := 'BLUE_INTEGER' else
if self.val = UInt32($8D98) then Result := 'RGB_INTEGER' else
if self.val = UInt32($8D99) then Result := 'RGBA_INTEGER' else
if self.val = UInt32($8D9A) then Result := 'BGR_INTEGER' else
if self.val = UInt32($8D9B) then Result := 'BGRA_INTEGER' else
Result := self.val.ToString;
end;
end;
PixelMap = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_MAP_I_TO_I := new PixelMap($0C70);
private static _PIXEL_MAP_S_TO_S := new PixelMap($0C71);
private static _PIXEL_MAP_I_TO_R := new PixelMap($0C72);
private static _PIXEL_MAP_I_TO_G := new PixelMap($0C73);
private static _PIXEL_MAP_I_TO_B := new PixelMap($0C74);
private static _PIXEL_MAP_I_TO_A := new PixelMap($0C75);
private static _PIXEL_MAP_R_TO_R := new PixelMap($0C76);
private static _PIXEL_MAP_G_TO_G := new PixelMap($0C77);
private static _PIXEL_MAP_B_TO_B := new PixelMap($0C78);
private static _PIXEL_MAP_A_TO_A := new PixelMap($0C79);
public static property PIXEL_MAP_I_TO_I: PixelMap read _PIXEL_MAP_I_TO_I;
public static property PIXEL_MAP_S_TO_S: PixelMap read _PIXEL_MAP_S_TO_S;
public static property PIXEL_MAP_I_TO_R: PixelMap read _PIXEL_MAP_I_TO_R;
public static property PIXEL_MAP_I_TO_G: PixelMap read _PIXEL_MAP_I_TO_G;
public static property PIXEL_MAP_I_TO_B: PixelMap read _PIXEL_MAP_I_TO_B;
public static property PIXEL_MAP_I_TO_A: PixelMap read _PIXEL_MAP_I_TO_A;
public static property PIXEL_MAP_R_TO_R: PixelMap read _PIXEL_MAP_R_TO_R;
public static property PIXEL_MAP_G_TO_G: PixelMap read _PIXEL_MAP_G_TO_G;
public static property PIXEL_MAP_B_TO_B: PixelMap read _PIXEL_MAP_B_TO_B;
public static property PIXEL_MAP_A_TO_A: PixelMap read _PIXEL_MAP_A_TO_A;
public function ToString: string; override;
begin
if self.val = UInt32($0C70) then Result := 'PIXEL_MAP_I_TO_I' else
if self.val = UInt32($0C71) then Result := 'PIXEL_MAP_S_TO_S' else
if self.val = UInt32($0C72) then Result := 'PIXEL_MAP_I_TO_R' else
if self.val = UInt32($0C73) then Result := 'PIXEL_MAP_I_TO_G' else
if self.val = UInt32($0C74) then Result := 'PIXEL_MAP_I_TO_B' else
if self.val = UInt32($0C75) then Result := 'PIXEL_MAP_I_TO_A' else
if self.val = UInt32($0C76) then Result := 'PIXEL_MAP_R_TO_R' else
if self.val = UInt32($0C77) then Result := 'PIXEL_MAP_G_TO_G' else
if self.val = UInt32($0C78) then Result := 'PIXEL_MAP_B_TO_B' else
if self.val = UInt32($0C79) then Result := 'PIXEL_MAP_A_TO_A' else
Result := self.val.ToString;
end;
end;
PixelStoreParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNPACK_SWAP_BYTES := new PixelStoreParameter($0CF0);
private static _UNPACK_LSB_FIRST := new PixelStoreParameter($0CF1);
private static _UNPACK_ROW_LENGTH := new PixelStoreParameter($0CF2);
private static _UNPACK_ROW_LENGTH_EXT := new PixelStoreParameter($0CF2);
private static _UNPACK_SKIP_ROWS := new PixelStoreParameter($0CF3);
private static _UNPACK_SKIP_ROWS_EXT := new PixelStoreParameter($0CF3);
private static _UNPACK_SKIP_PIXELS := new PixelStoreParameter($0CF4);
private static _UNPACK_SKIP_PIXELS_EXT := new PixelStoreParameter($0CF4);
private static _UNPACK_ALIGNMENT := new PixelStoreParameter($0CF5);
private static _PACK_SWAP_BYTES := new PixelStoreParameter($0D00);
private static _PACK_LSB_FIRST := new PixelStoreParameter($0D01);
private static _PACK_ROW_LENGTH := new PixelStoreParameter($0D02);
private static _PACK_SKIP_ROWS := new PixelStoreParameter($0D03);
private static _PACK_SKIP_PIXELS := new PixelStoreParameter($0D04);
private static _PACK_ALIGNMENT := new PixelStoreParameter($0D05);
private static _PACK_SKIP_IMAGES := new PixelStoreParameter($806B);
private static _PACK_SKIP_IMAGES_EXT := new PixelStoreParameter($806B);
private static _PACK_IMAGE_HEIGHT := new PixelStoreParameter($806C);
private static _PACK_IMAGE_HEIGHT_EXT := new PixelStoreParameter($806C);
private static _UNPACK_SKIP_IMAGES := new PixelStoreParameter($806D);
private static _UNPACK_SKIP_IMAGES_EXT := new PixelStoreParameter($806D);
private static _UNPACK_IMAGE_HEIGHT := new PixelStoreParameter($806E);
private static _UNPACK_IMAGE_HEIGHT_EXT := new PixelStoreParameter($806E);
private static _PACK_SKIP_VOLUMES_SGIS := new PixelStoreParameter($8130);
private static _PACK_IMAGE_DEPTH_SGIS := new PixelStoreParameter($8131);
private static _UNPACK_SKIP_VOLUMES_SGIS := new PixelStoreParameter($8132);
private static _UNPACK_IMAGE_DEPTH_SGIS := new PixelStoreParameter($8133);
private static _PIXEL_TILE_WIDTH_SGIX := new PixelStoreParameter($8140);
private static _PIXEL_TILE_HEIGHT_SGIX := new PixelStoreParameter($8141);
private static _PIXEL_TILE_GRID_WIDTH_SGIX := new PixelStoreParameter($8142);
private static _PIXEL_TILE_GRID_HEIGHT_SGIX := new PixelStoreParameter($8143);
private static _PIXEL_TILE_GRID_DEPTH_SGIX := new PixelStoreParameter($8144);
private static _PIXEL_TILE_CACHE_SIZE_SGIX := new PixelStoreParameter($8145);
private static _PACK_RESAMPLE_SGIX := new PixelStoreParameter($842E);
private static _UNPACK_RESAMPLE_SGIX := new PixelStoreParameter($842F);
private static _PACK_SUBSAMPLE_RATE_SGIX := new PixelStoreParameter($85A0);
private static _UNPACK_SUBSAMPLE_RATE_SGIX := new PixelStoreParameter($85A1);
private static _PACK_RESAMPLE_OML := new PixelStoreParameter($8984);
private static _UNPACK_RESAMPLE_OML := new PixelStoreParameter($8985);
public static property UNPACK_SWAP_BYTES: PixelStoreParameter read _UNPACK_SWAP_BYTES;
public static property UNPACK_LSB_FIRST: PixelStoreParameter read _UNPACK_LSB_FIRST;
public static property UNPACK_ROW_LENGTH: PixelStoreParameter read _UNPACK_ROW_LENGTH;
public static property UNPACK_ROW_LENGTH_EXT: PixelStoreParameter read _UNPACK_ROW_LENGTH_EXT;
public static property UNPACK_SKIP_ROWS: PixelStoreParameter read _UNPACK_SKIP_ROWS;
public static property UNPACK_SKIP_ROWS_EXT: PixelStoreParameter read _UNPACK_SKIP_ROWS_EXT;
public static property UNPACK_SKIP_PIXELS: PixelStoreParameter read _UNPACK_SKIP_PIXELS;
public static property UNPACK_SKIP_PIXELS_EXT: PixelStoreParameter read _UNPACK_SKIP_PIXELS_EXT;
public static property UNPACK_ALIGNMENT: PixelStoreParameter read _UNPACK_ALIGNMENT;
public static property PACK_SWAP_BYTES: PixelStoreParameter read _PACK_SWAP_BYTES;
public static property PACK_LSB_FIRST: PixelStoreParameter read _PACK_LSB_FIRST;
public static property PACK_ROW_LENGTH: PixelStoreParameter read _PACK_ROW_LENGTH;
public static property PACK_SKIP_ROWS: PixelStoreParameter read _PACK_SKIP_ROWS;
public static property PACK_SKIP_PIXELS: PixelStoreParameter read _PACK_SKIP_PIXELS;
public static property PACK_ALIGNMENT: PixelStoreParameter read _PACK_ALIGNMENT;
public static property PACK_SKIP_IMAGES: PixelStoreParameter read _PACK_SKIP_IMAGES;
public static property PACK_SKIP_IMAGES_EXT: PixelStoreParameter read _PACK_SKIP_IMAGES_EXT;
public static property PACK_IMAGE_HEIGHT: PixelStoreParameter read _PACK_IMAGE_HEIGHT;
public static property PACK_IMAGE_HEIGHT_EXT: PixelStoreParameter read _PACK_IMAGE_HEIGHT_EXT;
public static property UNPACK_SKIP_IMAGES: PixelStoreParameter read _UNPACK_SKIP_IMAGES;
public static property UNPACK_SKIP_IMAGES_EXT: PixelStoreParameter read _UNPACK_SKIP_IMAGES_EXT;
public static property UNPACK_IMAGE_HEIGHT: PixelStoreParameter read _UNPACK_IMAGE_HEIGHT;
public static property UNPACK_IMAGE_HEIGHT_EXT: PixelStoreParameter read _UNPACK_IMAGE_HEIGHT_EXT;
public static property PACK_SKIP_VOLUMES_SGIS: PixelStoreParameter read _PACK_SKIP_VOLUMES_SGIS;
public static property PACK_IMAGE_DEPTH_SGIS: PixelStoreParameter read _PACK_IMAGE_DEPTH_SGIS;
public static property UNPACK_SKIP_VOLUMES_SGIS: PixelStoreParameter read _UNPACK_SKIP_VOLUMES_SGIS;
public static property UNPACK_IMAGE_DEPTH_SGIS: PixelStoreParameter read _UNPACK_IMAGE_DEPTH_SGIS;
public static property PIXEL_TILE_WIDTH_SGIX: PixelStoreParameter read _PIXEL_TILE_WIDTH_SGIX;
public static property PIXEL_TILE_HEIGHT_SGIX: PixelStoreParameter read _PIXEL_TILE_HEIGHT_SGIX;
public static property PIXEL_TILE_GRID_WIDTH_SGIX: PixelStoreParameter read _PIXEL_TILE_GRID_WIDTH_SGIX;
public static property PIXEL_TILE_GRID_HEIGHT_SGIX: PixelStoreParameter read _PIXEL_TILE_GRID_HEIGHT_SGIX;
public static property PIXEL_TILE_GRID_DEPTH_SGIX: PixelStoreParameter read _PIXEL_TILE_GRID_DEPTH_SGIX;
public static property PIXEL_TILE_CACHE_SIZE_SGIX: PixelStoreParameter read _PIXEL_TILE_CACHE_SIZE_SGIX;
public static property PACK_RESAMPLE_SGIX: PixelStoreParameter read _PACK_RESAMPLE_SGIX;
public static property UNPACK_RESAMPLE_SGIX: PixelStoreParameter read _UNPACK_RESAMPLE_SGIX;
public static property PACK_SUBSAMPLE_RATE_SGIX: PixelStoreParameter read _PACK_SUBSAMPLE_RATE_SGIX;
public static property UNPACK_SUBSAMPLE_RATE_SGIX: PixelStoreParameter read _UNPACK_SUBSAMPLE_RATE_SGIX;
public static property PACK_RESAMPLE_OML: PixelStoreParameter read _PACK_RESAMPLE_OML;
public static property UNPACK_RESAMPLE_OML: PixelStoreParameter read _UNPACK_RESAMPLE_OML;
public function ToString: string; override;
begin
if self.val = UInt32($0CF0) then Result := 'UNPACK_SWAP_BYTES' else
if self.val = UInt32($0CF1) then Result := 'UNPACK_LSB_FIRST' else
if self.val = UInt32($0CF2) then Result := 'UNPACK_ROW_LENGTH' else
if self.val = UInt32($0CF2) then Result := 'UNPACK_ROW_LENGTH_EXT' else
if self.val = UInt32($0CF3) then Result := 'UNPACK_SKIP_ROWS' else
if self.val = UInt32($0CF3) then Result := 'UNPACK_SKIP_ROWS_EXT' else
if self.val = UInt32($0CF4) then Result := 'UNPACK_SKIP_PIXELS' else
if self.val = UInt32($0CF4) then Result := 'UNPACK_SKIP_PIXELS_EXT' else
if self.val = UInt32($0CF5) then Result := 'UNPACK_ALIGNMENT' else
if self.val = UInt32($0D00) then Result := 'PACK_SWAP_BYTES' else
if self.val = UInt32($0D01) then Result := 'PACK_LSB_FIRST' else
if self.val = UInt32($0D02) then Result := 'PACK_ROW_LENGTH' else
if self.val = UInt32($0D03) then Result := 'PACK_SKIP_ROWS' else
if self.val = UInt32($0D04) then Result := 'PACK_SKIP_PIXELS' else
if self.val = UInt32($0D05) then Result := 'PACK_ALIGNMENT' else
if self.val = UInt32($806B) then Result := 'PACK_SKIP_IMAGES' else
if self.val = UInt32($806B) then Result := 'PACK_SKIP_IMAGES_EXT' else
if self.val = UInt32($806C) then Result := 'PACK_IMAGE_HEIGHT' else
if self.val = UInt32($806C) then Result := 'PACK_IMAGE_HEIGHT_EXT' else
if self.val = UInt32($806D) then Result := 'UNPACK_SKIP_IMAGES' else
if self.val = UInt32($806D) then Result := 'UNPACK_SKIP_IMAGES_EXT' else
if self.val = UInt32($806E) then Result := 'UNPACK_IMAGE_HEIGHT' else
if self.val = UInt32($806E) then Result := 'UNPACK_IMAGE_HEIGHT_EXT' else
if self.val = UInt32($8130) then Result := 'PACK_SKIP_VOLUMES_SGIS' else
if self.val = UInt32($8131) then Result := 'PACK_IMAGE_DEPTH_SGIS' else
if self.val = UInt32($8132) then Result := 'UNPACK_SKIP_VOLUMES_SGIS' else
if self.val = UInt32($8133) then Result := 'UNPACK_IMAGE_DEPTH_SGIS' else
if self.val = UInt32($8140) then Result := 'PIXEL_TILE_WIDTH_SGIX' else
if self.val = UInt32($8141) then Result := 'PIXEL_TILE_HEIGHT_SGIX' else
if self.val = UInt32($8142) then Result := 'PIXEL_TILE_GRID_WIDTH_SGIX' else
if self.val = UInt32($8143) then Result := 'PIXEL_TILE_GRID_HEIGHT_SGIX' else
if self.val = UInt32($8144) then Result := 'PIXEL_TILE_GRID_DEPTH_SGIX' else
if self.val = UInt32($8145) then Result := 'PIXEL_TILE_CACHE_SIZE_SGIX' else
if self.val = UInt32($842E) then Result := 'PACK_RESAMPLE_SGIX' else
if self.val = UInt32($842F) then Result := 'UNPACK_RESAMPLE_SGIX' else
if self.val = UInt32($85A0) then Result := 'PACK_SUBSAMPLE_RATE_SGIX' else
if self.val = UInt32($85A1) then Result := 'UNPACK_SUBSAMPLE_RATE_SGIX' else
if self.val = UInt32($8984) then Result := 'PACK_RESAMPLE_OML' else
if self.val = UInt32($8985) then Result := 'UNPACK_RESAMPLE_OML' else
Result := self.val.ToString;
end;
end;
PixelTransferParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP_COLOR := new PixelTransferParameter($0D10);
private static _MAP_STENCIL := new PixelTransferParameter($0D11);
private static _INDEX_SHIFT := new PixelTransferParameter($0D12);
private static _INDEX_OFFSET := new PixelTransferParameter($0D13);
private static _RED_SCALE := new PixelTransferParameter($0D14);
private static _RED_BIAS := new PixelTransferParameter($0D15);
private static _GREEN_SCALE := new PixelTransferParameter($0D18);
private static _GREEN_BIAS := new PixelTransferParameter($0D19);
private static _BLUE_SCALE := new PixelTransferParameter($0D1A);
private static _BLUE_BIAS := new PixelTransferParameter($0D1B);
private static _ALPHA_SCALE := new PixelTransferParameter($0D1C);
private static _ALPHA_BIAS := new PixelTransferParameter($0D1D);
private static _DEPTH_SCALE := new PixelTransferParameter($0D1E);
private static _DEPTH_BIAS := new PixelTransferParameter($0D1F);
private static _POST_CONVOLUTION_RED_SCALE := new PixelTransferParameter($801C);
private static _POST_CONVOLUTION_RED_SCALE_EXT := new PixelTransferParameter($801C);
private static _POST_CONVOLUTION_GREEN_SCALE := new PixelTransferParameter($801D);
private static _POST_CONVOLUTION_GREEN_SCALE_EXT := new PixelTransferParameter($801D);
private static _POST_CONVOLUTION_BLUE_SCALE := new PixelTransferParameter($801E);
private static _POST_CONVOLUTION_BLUE_SCALE_EXT := new PixelTransferParameter($801E);
private static _POST_CONVOLUTION_ALPHA_SCALE := new PixelTransferParameter($801F);
private static _POST_CONVOLUTION_ALPHA_SCALE_EXT := new PixelTransferParameter($801F);
private static _POST_CONVOLUTION_RED_BIAS := new PixelTransferParameter($8020);
private static _POST_CONVOLUTION_RED_BIAS_EXT := new PixelTransferParameter($8020);
private static _POST_CONVOLUTION_GREEN_BIAS := new PixelTransferParameter($8021);
private static _POST_CONVOLUTION_GREEN_BIAS_EXT := new PixelTransferParameter($8021);
private static _POST_CONVOLUTION_BLUE_BIAS := new PixelTransferParameter($8022);
private static _POST_CONVOLUTION_BLUE_BIAS_EXT := new PixelTransferParameter($8022);
private static _POST_CONVOLUTION_ALPHA_BIAS := new PixelTransferParameter($8023);
private static _POST_CONVOLUTION_ALPHA_BIAS_EXT := new PixelTransferParameter($8023);
private static _POST_COLOR_MATRIX_RED_SCALE := new PixelTransferParameter($80B4);
private static _POST_COLOR_MATRIX_RED_SCALE_SGI := new PixelTransferParameter($80B4);
private static _POST_COLOR_MATRIX_GREEN_SCALE := new PixelTransferParameter($80B5);
private static _POST_COLOR_MATRIX_GREEN_SCALE_SGI := new PixelTransferParameter($80B5);
private static _POST_COLOR_MATRIX_BLUE_SCALE := new PixelTransferParameter($80B6);
private static _POST_COLOR_MATRIX_BLUE_SCALE_SGI := new PixelTransferParameter($80B6);
private static _POST_COLOR_MATRIX_ALPHA_SCALE := new PixelTransferParameter($80B7);
private static _POST_COLOR_MATRIX_ALPHA_SCALE_SGI := new PixelTransferParameter($80B7);
private static _POST_COLOR_MATRIX_RED_BIAS := new PixelTransferParameter($80B8);
private static _POST_COLOR_MATRIX_RED_BIAS_SGI := new PixelTransferParameter($80B8);
private static _POST_COLOR_MATRIX_GREEN_BIAS := new PixelTransferParameter($80B9);
private static _POST_COLOR_MATRIX_GREEN_BIAS_SGI := new PixelTransferParameter($80B9);
private static _POST_COLOR_MATRIX_BLUE_BIAS := new PixelTransferParameter($80BA);
private static _POST_COLOR_MATRIX_BLUE_BIAS_SGI := new PixelTransferParameter($80BA);
private static _POST_COLOR_MATRIX_ALPHA_BIAS := new PixelTransferParameter($80BB);
private static _POST_COLOR_MATRIX_ALPHA_BIAS_SGI := new PixelTransferParameter($80BB);
public static property MAP_COLOR: PixelTransferParameter read _MAP_COLOR;
public static property MAP_STENCIL: PixelTransferParameter read _MAP_STENCIL;
public static property INDEX_SHIFT: PixelTransferParameter read _INDEX_SHIFT;
public static property INDEX_OFFSET: PixelTransferParameter read _INDEX_OFFSET;
public static property RED_SCALE: PixelTransferParameter read _RED_SCALE;
public static property RED_BIAS: PixelTransferParameter read _RED_BIAS;
public static property GREEN_SCALE: PixelTransferParameter read _GREEN_SCALE;
public static property GREEN_BIAS: PixelTransferParameter read _GREEN_BIAS;
public static property BLUE_SCALE: PixelTransferParameter read _BLUE_SCALE;
public static property BLUE_BIAS: PixelTransferParameter read _BLUE_BIAS;
public static property ALPHA_SCALE: PixelTransferParameter read _ALPHA_SCALE;
public static property ALPHA_BIAS: PixelTransferParameter read _ALPHA_BIAS;
public static property DEPTH_SCALE: PixelTransferParameter read _DEPTH_SCALE;
public static property DEPTH_BIAS: PixelTransferParameter read _DEPTH_BIAS;
public static property POST_CONVOLUTION_RED_SCALE: PixelTransferParameter read _POST_CONVOLUTION_RED_SCALE;
public static property POST_CONVOLUTION_RED_SCALE_EXT: PixelTransferParameter read _POST_CONVOLUTION_RED_SCALE_EXT;
public static property POST_CONVOLUTION_GREEN_SCALE: PixelTransferParameter read _POST_CONVOLUTION_GREEN_SCALE;
public static property POST_CONVOLUTION_GREEN_SCALE_EXT: PixelTransferParameter read _POST_CONVOLUTION_GREEN_SCALE_EXT;
public static property POST_CONVOLUTION_BLUE_SCALE: PixelTransferParameter read _POST_CONVOLUTION_BLUE_SCALE;
public static property POST_CONVOLUTION_BLUE_SCALE_EXT: PixelTransferParameter read _POST_CONVOLUTION_BLUE_SCALE_EXT;
public static property POST_CONVOLUTION_ALPHA_SCALE: PixelTransferParameter read _POST_CONVOLUTION_ALPHA_SCALE;
public static property POST_CONVOLUTION_ALPHA_SCALE_EXT: PixelTransferParameter read _POST_CONVOLUTION_ALPHA_SCALE_EXT;
public static property POST_CONVOLUTION_RED_BIAS: PixelTransferParameter read _POST_CONVOLUTION_RED_BIAS;
public static property POST_CONVOLUTION_RED_BIAS_EXT: PixelTransferParameter read _POST_CONVOLUTION_RED_BIAS_EXT;
public static property POST_CONVOLUTION_GREEN_BIAS: PixelTransferParameter read _POST_CONVOLUTION_GREEN_BIAS;
public static property POST_CONVOLUTION_GREEN_BIAS_EXT: PixelTransferParameter read _POST_CONVOLUTION_GREEN_BIAS_EXT;
public static property POST_CONVOLUTION_BLUE_BIAS: PixelTransferParameter read _POST_CONVOLUTION_BLUE_BIAS;
public static property POST_CONVOLUTION_BLUE_BIAS_EXT: PixelTransferParameter read _POST_CONVOLUTION_BLUE_BIAS_EXT;
public static property POST_CONVOLUTION_ALPHA_BIAS: PixelTransferParameter read _POST_CONVOLUTION_ALPHA_BIAS;
public static property POST_CONVOLUTION_ALPHA_BIAS_EXT: PixelTransferParameter read _POST_CONVOLUTION_ALPHA_BIAS_EXT;
public static property POST_COLOR_MATRIX_RED_SCALE: PixelTransferParameter read _POST_COLOR_MATRIX_RED_SCALE;
public static property POST_COLOR_MATRIX_RED_SCALE_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_RED_SCALE_SGI;
public static property POST_COLOR_MATRIX_GREEN_SCALE: PixelTransferParameter read _POST_COLOR_MATRIX_GREEN_SCALE;
public static property POST_COLOR_MATRIX_GREEN_SCALE_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_GREEN_SCALE_SGI;
public static property POST_COLOR_MATRIX_BLUE_SCALE: PixelTransferParameter read _POST_COLOR_MATRIX_BLUE_SCALE;
public static property POST_COLOR_MATRIX_BLUE_SCALE_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_BLUE_SCALE_SGI;
public static property POST_COLOR_MATRIX_ALPHA_SCALE: PixelTransferParameter read _POST_COLOR_MATRIX_ALPHA_SCALE;
public static property POST_COLOR_MATRIX_ALPHA_SCALE_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_ALPHA_SCALE_SGI;
public static property POST_COLOR_MATRIX_RED_BIAS: PixelTransferParameter read _POST_COLOR_MATRIX_RED_BIAS;
public static property POST_COLOR_MATRIX_RED_BIAS_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_RED_BIAS_SGI;
public static property POST_COLOR_MATRIX_GREEN_BIAS: PixelTransferParameter read _POST_COLOR_MATRIX_GREEN_BIAS;
public static property POST_COLOR_MATRIX_GREEN_BIAS_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_GREEN_BIAS_SGI;
public static property POST_COLOR_MATRIX_BLUE_BIAS: PixelTransferParameter read _POST_COLOR_MATRIX_BLUE_BIAS;
public static property POST_COLOR_MATRIX_BLUE_BIAS_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_BLUE_BIAS_SGI;
public static property POST_COLOR_MATRIX_ALPHA_BIAS: PixelTransferParameter read _POST_COLOR_MATRIX_ALPHA_BIAS;
public static property POST_COLOR_MATRIX_ALPHA_BIAS_SGI: PixelTransferParameter read _POST_COLOR_MATRIX_ALPHA_BIAS_SGI;
public function ToString: string; override;
begin
if self.val = UInt32($0D10) then Result := 'MAP_COLOR' else
if self.val = UInt32($0D11) then Result := 'MAP_STENCIL' else
if self.val = UInt32($0D12) then Result := 'INDEX_SHIFT' else
if self.val = UInt32($0D13) then Result := 'INDEX_OFFSET' else
if self.val = UInt32($0D14) then Result := 'RED_SCALE' else
if self.val = UInt32($0D15) then Result := 'RED_BIAS' else
if self.val = UInt32($0D18) then Result := 'GREEN_SCALE' else
if self.val = UInt32($0D19) then Result := 'GREEN_BIAS' else
if self.val = UInt32($0D1A) then Result := 'BLUE_SCALE' else
if self.val = UInt32($0D1B) then Result := 'BLUE_BIAS' else
if self.val = UInt32($0D1C) then Result := 'ALPHA_SCALE' else
if self.val = UInt32($0D1D) then Result := 'ALPHA_BIAS' else
if self.val = UInt32($0D1E) then Result := 'DEPTH_SCALE' else
if self.val = UInt32($0D1F) then Result := 'DEPTH_BIAS' else
if self.val = UInt32($801C) then Result := 'POST_CONVOLUTION_RED_SCALE' else
if self.val = UInt32($801C) then Result := 'POST_CONVOLUTION_RED_SCALE_EXT' else
if self.val = UInt32($801D) then Result := 'POST_CONVOLUTION_GREEN_SCALE' else
if self.val = UInt32($801D) then Result := 'POST_CONVOLUTION_GREEN_SCALE_EXT' else
if self.val = UInt32($801E) then Result := 'POST_CONVOLUTION_BLUE_SCALE' else
if self.val = UInt32($801E) then Result := 'POST_CONVOLUTION_BLUE_SCALE_EXT' else
if self.val = UInt32($801F) then Result := 'POST_CONVOLUTION_ALPHA_SCALE' else
if self.val = UInt32($801F) then Result := 'POST_CONVOLUTION_ALPHA_SCALE_EXT' else
if self.val = UInt32($8020) then Result := 'POST_CONVOLUTION_RED_BIAS' else
if self.val = UInt32($8020) then Result := 'POST_CONVOLUTION_RED_BIAS_EXT' else
if self.val = UInt32($8021) then Result := 'POST_CONVOLUTION_GREEN_BIAS' else
if self.val = UInt32($8021) then Result := 'POST_CONVOLUTION_GREEN_BIAS_EXT' else
if self.val = UInt32($8022) then Result := 'POST_CONVOLUTION_BLUE_BIAS' else
if self.val = UInt32($8022) then Result := 'POST_CONVOLUTION_BLUE_BIAS_EXT' else
if self.val = UInt32($8023) then Result := 'POST_CONVOLUTION_ALPHA_BIAS' else
if self.val = UInt32($8023) then Result := 'POST_CONVOLUTION_ALPHA_BIAS_EXT' else
if self.val = UInt32($80B4) then Result := 'POST_COLOR_MATRIX_RED_SCALE' else
if self.val = UInt32($80B4) then Result := 'POST_COLOR_MATRIX_RED_SCALE_SGI' else
if self.val = UInt32($80B5) then Result := 'POST_COLOR_MATRIX_GREEN_SCALE' else
if self.val = UInt32($80B5) then Result := 'POST_COLOR_MATRIX_GREEN_SCALE_SGI' else
if self.val = UInt32($80B6) then Result := 'POST_COLOR_MATRIX_BLUE_SCALE' else
if self.val = UInt32($80B6) then Result := 'POST_COLOR_MATRIX_BLUE_SCALE_SGI' else
if self.val = UInt32($80B7) then Result := 'POST_COLOR_MATRIX_ALPHA_SCALE' else
if self.val = UInt32($80B7) then Result := 'POST_COLOR_MATRIX_ALPHA_SCALE_SGI' else
if self.val = UInt32($80B8) then Result := 'POST_COLOR_MATRIX_RED_BIAS' else
if self.val = UInt32($80B8) then Result := 'POST_COLOR_MATRIX_RED_BIAS_SGI' else
if self.val = UInt32($80B9) then Result := 'POST_COLOR_MATRIX_GREEN_BIAS' else
if self.val = UInt32($80B9) then Result := 'POST_COLOR_MATRIX_GREEN_BIAS_SGI' else
if self.val = UInt32($80BA) then Result := 'POST_COLOR_MATRIX_BLUE_BIAS' else
if self.val = UInt32($80BA) then Result := 'POST_COLOR_MATRIX_BLUE_BIAS_SGI' else
if self.val = UInt32($80BB) then Result := 'POST_COLOR_MATRIX_ALPHA_BIAS' else
if self.val = UInt32($80BB) then Result := 'POST_COLOR_MATRIX_ALPHA_BIAS_SGI' else
Result := self.val.ToString;
end;
end;
PixelType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new PixelType($1400);
private static _UNSIGNED_BYTE := new PixelType($1401);
private static _SHORT := new PixelType($1402);
private static _UNSIGNED_SHORT := new PixelType($1403);
private static _INT := new PixelType($1404);
private static _UNSIGNED_INT := new PixelType($1405);
private static _FLOAT := new PixelType($1406);
private static _BITMAP := new PixelType($1A00);
private static _UNSIGNED_BYTE_3_3_2 := new PixelType($8032);
private static _UNSIGNED_BYTE_3_3_2_EXT := new PixelType($8032);
private static _UNSIGNED_SHORT_4_4_4_4 := new PixelType($8033);
private static _UNSIGNED_SHORT_4_4_4_4_EXT := new PixelType($8033);
private static _UNSIGNED_SHORT_5_5_5_1 := new PixelType($8034);
private static _UNSIGNED_SHORT_5_5_5_1_EXT := new PixelType($8034);
private static _UNSIGNED_INT_8_8_8_8 := new PixelType($8035);
private static _UNSIGNED_INT_8_8_8_8_EXT := new PixelType($8035);
private static _UNSIGNED_INT_10_10_10_2 := new PixelType($8036);
private static _UNSIGNED_INT_10_10_10_2_EXT := new PixelType($8036);
public static property BYTE: PixelType read _BYTE;
public static property UNSIGNED_BYTE: PixelType read _UNSIGNED_BYTE;
public static property SHORT: PixelType read _SHORT;
public static property UNSIGNED_SHORT: PixelType read _UNSIGNED_SHORT;
public static property INT: PixelType read _INT;
public static property UNSIGNED_INT: PixelType read _UNSIGNED_INT;
public static property FLOAT: PixelType read _FLOAT;
public static property BITMAP: PixelType read _BITMAP;
public static property UNSIGNED_BYTE_3_3_2: PixelType read _UNSIGNED_BYTE_3_3_2;
public static property UNSIGNED_BYTE_3_3_2_EXT: PixelType read _UNSIGNED_BYTE_3_3_2_EXT;
public static property UNSIGNED_SHORT_4_4_4_4: PixelType read _UNSIGNED_SHORT_4_4_4_4;
public static property UNSIGNED_SHORT_4_4_4_4_EXT: PixelType read _UNSIGNED_SHORT_4_4_4_4_EXT;
public static property UNSIGNED_SHORT_5_5_5_1: PixelType read _UNSIGNED_SHORT_5_5_5_1;
public static property UNSIGNED_SHORT_5_5_5_1_EXT: PixelType read _UNSIGNED_SHORT_5_5_5_1_EXT;
public static property UNSIGNED_INT_8_8_8_8: PixelType read _UNSIGNED_INT_8_8_8_8;
public static property UNSIGNED_INT_8_8_8_8_EXT: PixelType read _UNSIGNED_INT_8_8_8_8_EXT;
public static property UNSIGNED_INT_10_10_10_2: PixelType read _UNSIGNED_INT_10_10_10_2;
public static property UNSIGNED_INT_10_10_10_2_EXT: PixelType read _UNSIGNED_INT_10_10_10_2_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($1A00) then Result := 'BITMAP' else
if self.val = UInt32($8032) then Result := 'UNSIGNED_BYTE_3_3_2' else
if self.val = UInt32($8032) then Result := 'UNSIGNED_BYTE_3_3_2_EXT' else
if self.val = UInt32($8033) then Result := 'UNSIGNED_SHORT_4_4_4_4' else
if self.val = UInt32($8033) then Result := 'UNSIGNED_SHORT_4_4_4_4_EXT' else
if self.val = UInt32($8034) then Result := 'UNSIGNED_SHORT_5_5_5_1' else
if self.val = UInt32($8034) then Result := 'UNSIGNED_SHORT_5_5_5_1_EXT' else
if self.val = UInt32($8035) then Result := 'UNSIGNED_INT_8_8_8_8' else
if self.val = UInt32($8035) then Result := 'UNSIGNED_INT_8_8_8_8_EXT' else
if self.val = UInt32($8036) then Result := 'UNSIGNED_INT_10_10_10_2' else
if self.val = UInt32($8036) then Result := 'UNSIGNED_INT_10_10_10_2_EXT' else
Result := self.val.ToString;
end;
end;
PolygonMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINT := new PolygonMode($1B00);
private static _LINE := new PolygonMode($1B01);
private static _FILL := new PolygonMode($1B02);
public static property POINT: PolygonMode read _POINT;
public static property LINE: PolygonMode read _LINE;
public static property FILL: PolygonMode read _FILL;
public function ToString: string; override;
begin
if self.val = UInt32($1B00) then Result := 'POINT' else
if self.val = UInt32($1B01) then Result := 'LINE' else
if self.val = UInt32($1B02) then Result := 'FILL' else
Result := self.val.ToString;
end;
end;
PrecisionType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LOW_FLOAT := new PrecisionType($8DF0);
private static _MEDIUM_FLOAT := new PrecisionType($8DF1);
private static _HIGH_FLOAT := new PrecisionType($8DF2);
private static _LOW_INT := new PrecisionType($8DF3);
private static _MEDIUM_INT := new PrecisionType($8DF4);
private static _HIGH_INT := new PrecisionType($8DF5);
public static property LOW_FLOAT: PrecisionType read _LOW_FLOAT;
public static property MEDIUM_FLOAT: PrecisionType read _MEDIUM_FLOAT;
public static property HIGH_FLOAT: PrecisionType read _HIGH_FLOAT;
public static property LOW_INT: PrecisionType read _LOW_INT;
public static property MEDIUM_INT: PrecisionType read _MEDIUM_INT;
public static property HIGH_INT: PrecisionType read _HIGH_INT;
public function ToString: string; override;
begin
if self.val = UInt32($8DF0) then Result := 'LOW_FLOAT' else
if self.val = UInt32($8DF1) then Result := 'MEDIUM_FLOAT' else
if self.val = UInt32($8DF2) then Result := 'HIGH_FLOAT' else
if self.val = UInt32($8DF3) then Result := 'LOW_INT' else
if self.val = UInt32($8DF4) then Result := 'MEDIUM_INT' else
if self.val = UInt32($8DF5) then Result := 'HIGH_INT' else
Result := self.val.ToString;
end;
end;
PrimitiveType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINTS := new PrimitiveType($0000);
private static _LINES := new PrimitiveType($0001);
private static _LINE_LOOP := new PrimitiveType($0002);
private static _LINE_STRIP := new PrimitiveType($0003);
private static _TRIANGLES := new PrimitiveType($0004);
private static _TRIANGLE_STRIP := new PrimitiveType($0005);
private static _TRIANGLE_FAN := new PrimitiveType($0006);
private static _QUADS := new PrimitiveType($0007);
private static _QUADS_EXT := new PrimitiveType($0007);
private static _QUAD_STRIP := new PrimitiveType($0008);
private static _POLYGON := new PrimitiveType($0009);
private static _LINES_ADJACENCY := new PrimitiveType($000A);
private static _LINES_ADJACENCY_ARB := new PrimitiveType($000A);
private static _LINES_ADJACENCY_EXT := new PrimitiveType($000A);
private static _LINE_STRIP_ADJACENCY := new PrimitiveType($000B);
private static _LINE_STRIP_ADJACENCY_ARB := new PrimitiveType($000B);
private static _LINE_STRIP_ADJACENCY_EXT := new PrimitiveType($000B);
private static _TRIANGLES_ADJACENCY := new PrimitiveType($000C);
private static _TRIANGLES_ADJACENCY_ARB := new PrimitiveType($000C);
private static _TRIANGLES_ADJACENCY_EXT := new PrimitiveType($000C);
private static _TRIANGLE_STRIP_ADJACENCY := new PrimitiveType($000D);
private static _TRIANGLE_STRIP_ADJACENCY_ARB := new PrimitiveType($000D);
private static _TRIANGLE_STRIP_ADJACENCY_EXT := new PrimitiveType($000D);
private static _PATCHES := new PrimitiveType($000E);
private static _PATCHES_EXT := new PrimitiveType($000E);
public static property POINTS: PrimitiveType read _POINTS;
public static property LINES: PrimitiveType read _LINES;
public static property LINE_LOOP: PrimitiveType read _LINE_LOOP;
public static property LINE_STRIP: PrimitiveType read _LINE_STRIP;
public static property TRIANGLES: PrimitiveType read _TRIANGLES;
public static property TRIANGLE_STRIP: PrimitiveType read _TRIANGLE_STRIP;
public static property TRIANGLE_FAN: PrimitiveType read _TRIANGLE_FAN;
public static property QUADS: PrimitiveType read _QUADS;
public static property QUADS_EXT: PrimitiveType read _QUADS_EXT;
public static property QUAD_STRIP: PrimitiveType read _QUAD_STRIP;
public static property POLYGON: PrimitiveType read _POLYGON;
public static property LINES_ADJACENCY: PrimitiveType read _LINES_ADJACENCY;
public static property LINES_ADJACENCY_ARB: PrimitiveType read _LINES_ADJACENCY_ARB;
public static property LINES_ADJACENCY_EXT: PrimitiveType read _LINES_ADJACENCY_EXT;
public static property LINE_STRIP_ADJACENCY: PrimitiveType read _LINE_STRIP_ADJACENCY;
public static property LINE_STRIP_ADJACENCY_ARB: PrimitiveType read _LINE_STRIP_ADJACENCY_ARB;
public static property LINE_STRIP_ADJACENCY_EXT: PrimitiveType read _LINE_STRIP_ADJACENCY_EXT;
public static property TRIANGLES_ADJACENCY: PrimitiveType read _TRIANGLES_ADJACENCY;
public static property TRIANGLES_ADJACENCY_ARB: PrimitiveType read _TRIANGLES_ADJACENCY_ARB;
public static property TRIANGLES_ADJACENCY_EXT: PrimitiveType read _TRIANGLES_ADJACENCY_EXT;
public static property TRIANGLE_STRIP_ADJACENCY: PrimitiveType read _TRIANGLE_STRIP_ADJACENCY;
public static property TRIANGLE_STRIP_ADJACENCY_ARB: PrimitiveType read _TRIANGLE_STRIP_ADJACENCY_ARB;
public static property TRIANGLE_STRIP_ADJACENCY_EXT: PrimitiveType read _TRIANGLE_STRIP_ADJACENCY_EXT;
public static property PATCHES: PrimitiveType read _PATCHES;
public static property PATCHES_EXT: PrimitiveType read _PATCHES_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'POINTS' else
if self.val = UInt32($0001) then Result := 'LINES' else
if self.val = UInt32($0002) then Result := 'LINE_LOOP' else
if self.val = UInt32($0003) then Result := 'LINE_STRIP' else
if self.val = UInt32($0004) then Result := 'TRIANGLES' else
if self.val = UInt32($0005) then Result := 'TRIANGLE_STRIP' else
if self.val = UInt32($0006) then Result := 'TRIANGLE_FAN' else
if self.val = UInt32($0007) then Result := 'QUADS' else
if self.val = UInt32($0007) then Result := 'QUADS_EXT' else
if self.val = UInt32($0008) then Result := 'QUAD_STRIP' else
if self.val = UInt32($0009) then Result := 'POLYGON' else
if self.val = UInt32($000A) then Result := 'LINES_ADJACENCY' else
if self.val = UInt32($000A) then Result := 'LINES_ADJACENCY_ARB' else
if self.val = UInt32($000A) then Result := 'LINES_ADJACENCY_EXT' else
if self.val = UInt32($000B) then Result := 'LINE_STRIP_ADJACENCY' else
if self.val = UInt32($000B) then Result := 'LINE_STRIP_ADJACENCY_ARB' else
if self.val = UInt32($000B) then Result := 'LINE_STRIP_ADJACENCY_EXT' else
if self.val = UInt32($000C) then Result := 'TRIANGLES_ADJACENCY' else
if self.val = UInt32($000C) then Result := 'TRIANGLES_ADJACENCY_ARB' else
if self.val = UInt32($000C) then Result := 'TRIANGLES_ADJACENCY_EXT' else
if self.val = UInt32($000D) then Result := 'TRIANGLE_STRIP_ADJACENCY' else
if self.val = UInt32($000D) then Result := 'TRIANGLE_STRIP_ADJACENCY_ARB' else
if self.val = UInt32($000D) then Result := 'TRIANGLE_STRIP_ADJACENCY_EXT' else
if self.val = UInt32($000E) then Result := 'PATCHES' else
if self.val = UInt32($000E) then Result := 'PATCHES_EXT' else
Result := self.val.ToString;
end;
end;
ProgramFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PROGRAM_FORMAT_ASCII_ARB := new ProgramFormat($8875);
public static property PROGRAM_FORMAT_ASCII_ARB: ProgramFormat read _PROGRAM_FORMAT_ASCII_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($8875) then Result := 'PROGRAM_FORMAT_ASCII_ARB' else
Result := self.val.ToString;
end;
end;
ProgramInterface = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TRANSFORM_FEEDBACK_BUFFER := new ProgramInterface($8C8E);
private static _UNIFORM := new ProgramInterface($92E1);
private static _UNIFORM_BLOCK := new ProgramInterface($92E2);
private static _PROGRAM_INPUT := new ProgramInterface($92E3);
private static _PROGRAM_OUTPUT := new ProgramInterface($92E4);
private static _BUFFER_VARIABLE := new ProgramInterface($92E5);
private static _SHADER_STORAGE_BLOCK := new ProgramInterface($92E6);
private static _VERTEX_SUBROUTINE := new ProgramInterface($92E8);
private static _TESS_CONTROL_SUBROUTINE := new ProgramInterface($92E9);
private static _TESS_EVALUATION_SUBROUTINE := new ProgramInterface($92EA);
private static _GEOMETRY_SUBROUTINE := new ProgramInterface($92EB);
private static _FRAGMENT_SUBROUTINE := new ProgramInterface($92EC);
private static _COMPUTE_SUBROUTINE := new ProgramInterface($92ED);
private static _VERTEX_SUBROUTINE_UNIFORM := new ProgramInterface($92EE);
private static _TESS_CONTROL_SUBROUTINE_UNIFORM := new ProgramInterface($92EF);
private static _TESS_EVALUATION_SUBROUTINE_UNIFORM := new ProgramInterface($92F0);
private static _GEOMETRY_SUBROUTINE_UNIFORM := new ProgramInterface($92F1);
private static _FRAGMENT_SUBROUTINE_UNIFORM := new ProgramInterface($92F2);
private static _COMPUTE_SUBROUTINE_UNIFORM := new ProgramInterface($92F3);
private static _TRANSFORM_FEEDBACK_VARYING := new ProgramInterface($92F4);
public static property TRANSFORM_FEEDBACK_BUFFER: ProgramInterface read _TRANSFORM_FEEDBACK_BUFFER;
public static property UNIFORM: ProgramInterface read _UNIFORM;
public static property UNIFORM_BLOCK: ProgramInterface read _UNIFORM_BLOCK;
public static property PROGRAM_INPUT: ProgramInterface read _PROGRAM_INPUT;
public static property PROGRAM_OUTPUT: ProgramInterface read _PROGRAM_OUTPUT;
public static property BUFFER_VARIABLE: ProgramInterface read _BUFFER_VARIABLE;
public static property SHADER_STORAGE_BLOCK: ProgramInterface read _SHADER_STORAGE_BLOCK;
public static property VERTEX_SUBROUTINE: ProgramInterface read _VERTEX_SUBROUTINE;
public static property TESS_CONTROL_SUBROUTINE: ProgramInterface read _TESS_CONTROL_SUBROUTINE;
public static property TESS_EVALUATION_SUBROUTINE: ProgramInterface read _TESS_EVALUATION_SUBROUTINE;
public static property GEOMETRY_SUBROUTINE: ProgramInterface read _GEOMETRY_SUBROUTINE;
public static property FRAGMENT_SUBROUTINE: ProgramInterface read _FRAGMENT_SUBROUTINE;
public static property COMPUTE_SUBROUTINE: ProgramInterface read _COMPUTE_SUBROUTINE;
public static property VERTEX_SUBROUTINE_UNIFORM: ProgramInterface read _VERTEX_SUBROUTINE_UNIFORM;
public static property TESS_CONTROL_SUBROUTINE_UNIFORM: ProgramInterface read _TESS_CONTROL_SUBROUTINE_UNIFORM;
public static property TESS_EVALUATION_SUBROUTINE_UNIFORM: ProgramInterface read _TESS_EVALUATION_SUBROUTINE_UNIFORM;
public static property GEOMETRY_SUBROUTINE_UNIFORM: ProgramInterface read _GEOMETRY_SUBROUTINE_UNIFORM;
public static property FRAGMENT_SUBROUTINE_UNIFORM: ProgramInterface read _FRAGMENT_SUBROUTINE_UNIFORM;
public static property COMPUTE_SUBROUTINE_UNIFORM: ProgramInterface read _COMPUTE_SUBROUTINE_UNIFORM;
public static property TRANSFORM_FEEDBACK_VARYING: ProgramInterface read _TRANSFORM_FEEDBACK_VARYING;
public function ToString: string; override;
begin
if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
if self.val = UInt32($92E1) then Result := 'UNIFORM' else
if self.val = UInt32($92E2) then Result := 'UNIFORM_BLOCK' else
if self.val = UInt32($92E3) then Result := 'PROGRAM_INPUT' else
if self.val = UInt32($92E4) then Result := 'PROGRAM_OUTPUT' else
if self.val = UInt32($92E5) then Result := 'BUFFER_VARIABLE' else
if self.val = UInt32($92E6) then Result := 'SHADER_STORAGE_BLOCK' else
if self.val = UInt32($92E8) then Result := 'VERTEX_SUBROUTINE' else
if self.val = UInt32($92E9) then Result := 'TESS_CONTROL_SUBROUTINE' else
if self.val = UInt32($92EA) then Result := 'TESS_EVALUATION_SUBROUTINE' else
if self.val = UInt32($92EB) then Result := 'GEOMETRY_SUBROUTINE' else
if self.val = UInt32($92EC) then Result := 'FRAGMENT_SUBROUTINE' else
if self.val = UInt32($92ED) then Result := 'COMPUTE_SUBROUTINE' else
if self.val = UInt32($92EE) then Result := 'VERTEX_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92EF) then Result := 'TESS_CONTROL_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92F0) then Result := 'TESS_EVALUATION_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92F1) then Result := 'GEOMETRY_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92F2) then Result := 'FRAGMENT_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92F3) then Result := 'COMPUTE_SUBROUTINE_UNIFORM' else
if self.val = UInt32($92F4) then Result := 'TRANSFORM_FEEDBACK_VARYING' else
Result := self.val.ToString;
end;
end;
ProgramInterfacePName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ACTIVE_RESOURCES := new ProgramInterfacePName($92F5);
private static _MAX_NAME_LENGTH := new ProgramInterfacePName($92F6);
private static _MAX_NUM_ACTIVE_VARIABLES := new ProgramInterfacePName($92F7);
private static _MAX_NUM_COMPATIBLE_SUBROUTINES := new ProgramInterfacePName($92F8);
public static property ACTIVE_RESOURCES: ProgramInterfacePName read _ACTIVE_RESOURCES;
public static property MAX_NAME_LENGTH: ProgramInterfacePName read _MAX_NAME_LENGTH;
public static property MAX_NUM_ACTIVE_VARIABLES: ProgramInterfacePName read _MAX_NUM_ACTIVE_VARIABLES;
public static property MAX_NUM_COMPATIBLE_SUBROUTINES: ProgramInterfacePName read _MAX_NUM_COMPATIBLE_SUBROUTINES;
public function ToString: string; override;
begin
if self.val = UInt32($92F5) then Result := 'ACTIVE_RESOURCES' else
if self.val = UInt32($92F6) then Result := 'MAX_NAME_LENGTH' else
if self.val = UInt32($92F7) then Result := 'MAX_NUM_ACTIVE_VARIABLES' else
if self.val = UInt32($92F8) then Result := 'MAX_NUM_COMPATIBLE_SUBROUTINES' else
Result := self.val.ToString;
end;
end;
ProgramParameterPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PROGRAM_BINARY_RETRIEVABLE_HINT := new ProgramParameterPName($8257);
private static _PROGRAM_SEPARABLE := new ProgramParameterPName($8258);
public static property PROGRAM_BINARY_RETRIEVABLE_HINT: ProgramParameterPName read _PROGRAM_BINARY_RETRIEVABLE_HINT;
public static property PROGRAM_SEPARABLE: ProgramParameterPName read _PROGRAM_SEPARABLE;
public function ToString: string; override;
begin
if self.val = UInt32($8257) then Result := 'PROGRAM_BINARY_RETRIEVABLE_HINT' else
if self.val = UInt32($8258) then Result := 'PROGRAM_SEPARABLE' else
Result := self.val.ToString;
end;
end;
ProgramResourceProperty = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NUM_COMPATIBLE_SUBROUTINES := new ProgramResourceProperty($8E4A);
private static _COMPATIBLE_SUBROUTINES := new ProgramResourceProperty($8E4B);
private static _UNIFORM := new ProgramResourceProperty($92E1);
private static _IS_PER_PATCH := new ProgramResourceProperty($92E7);
private static _NAME_LENGTH := new ProgramResourceProperty($92F9);
private static _TYPE := new ProgramResourceProperty($92FA);
private static _ARRAY_SIZE := new ProgramResourceProperty($92FB);
private static _OFFSET := new ProgramResourceProperty($92FC);
private static _BLOCK_INDEX := new ProgramResourceProperty($92FD);
private static _ARRAY_STRIDE := new ProgramResourceProperty($92FE);
private static _MATRIX_STRIDE := new ProgramResourceProperty($92FF);
private static _IS_ROW_MAJOR := new ProgramResourceProperty($9300);
private static _ATOMIC_COUNTER_BUFFER_INDEX := new ProgramResourceProperty($9301);
private static _BUFFER_BINDING := new ProgramResourceProperty($9302);
private static _BUFFER_DATA_SIZE := new ProgramResourceProperty($9303);
private static _NUM_ACTIVE_VARIABLES := new ProgramResourceProperty($9304);
private static _ACTIVE_VARIABLES := new ProgramResourceProperty($9305);
private static _REFERENCED_BY_VERTEX_SHADER := new ProgramResourceProperty($9306);
private static _REFERENCED_BY_TESS_CONTROL_SHADER := new ProgramResourceProperty($9307);
private static _REFERENCED_BY_TESS_EVALUATION_SHADER := new ProgramResourceProperty($9308);
private static _REFERENCED_BY_GEOMETRY_SHADER := new ProgramResourceProperty($9309);
private static _REFERENCED_BY_FRAGMENT_SHADER := new ProgramResourceProperty($930A);
private static _REFERENCED_BY_COMPUTE_SHADER := new ProgramResourceProperty($930B);
private static _TOP_LEVEL_ARRAY_SIZE := new ProgramResourceProperty($930C);
private static _TOP_LEVEL_ARRAY_STRIDE := new ProgramResourceProperty($930D);
private static _LOCATION := new ProgramResourceProperty($930E);
private static _LOCATION_INDEX := new ProgramResourceProperty($930F);
private static _LOCATION_COMPONENT := new ProgramResourceProperty($934A);
private static _TRANSFORM_FEEDBACK_BUFFER_INDEX := new ProgramResourceProperty($934B);
private static _TRANSFORM_FEEDBACK_BUFFER_STRIDE := new ProgramResourceProperty($934C);
public static property NUM_COMPATIBLE_SUBROUTINES: ProgramResourceProperty read _NUM_COMPATIBLE_SUBROUTINES;
public static property COMPATIBLE_SUBROUTINES: ProgramResourceProperty read _COMPATIBLE_SUBROUTINES;
public static property UNIFORM: ProgramResourceProperty read _UNIFORM;
public static property IS_PER_PATCH: ProgramResourceProperty read _IS_PER_PATCH;
public static property NAME_LENGTH: ProgramResourceProperty read _NAME_LENGTH;
public static property &TYPE: ProgramResourceProperty read _TYPE;
public static property ARRAY_SIZE: ProgramResourceProperty read _ARRAY_SIZE;
public static property OFFSET: ProgramResourceProperty read _OFFSET;
public static property BLOCK_INDEX: ProgramResourceProperty read _BLOCK_INDEX;
public static property ARRAY_STRIDE: ProgramResourceProperty read _ARRAY_STRIDE;
public static property MATRIX_STRIDE: ProgramResourceProperty read _MATRIX_STRIDE;
public static property IS_ROW_MAJOR: ProgramResourceProperty read _IS_ROW_MAJOR;
public static property ATOMIC_COUNTER_BUFFER_INDEX: ProgramResourceProperty read _ATOMIC_COUNTER_BUFFER_INDEX;
public static property BUFFER_BINDING: ProgramResourceProperty read _BUFFER_BINDING;
public static property BUFFER_DATA_SIZE: ProgramResourceProperty read _BUFFER_DATA_SIZE;
public static property NUM_ACTIVE_VARIABLES: ProgramResourceProperty read _NUM_ACTIVE_VARIABLES;
public static property ACTIVE_VARIABLES: ProgramResourceProperty read _ACTIVE_VARIABLES;
public static property REFERENCED_BY_VERTEX_SHADER: ProgramResourceProperty read _REFERENCED_BY_VERTEX_SHADER;
public static property REFERENCED_BY_TESS_CONTROL_SHADER: ProgramResourceProperty read _REFERENCED_BY_TESS_CONTROL_SHADER;
public static property REFERENCED_BY_TESS_EVALUATION_SHADER: ProgramResourceProperty read _REFERENCED_BY_TESS_EVALUATION_SHADER;
public static property REFERENCED_BY_GEOMETRY_SHADER: ProgramResourceProperty read _REFERENCED_BY_GEOMETRY_SHADER;
public static property REFERENCED_BY_FRAGMENT_SHADER: ProgramResourceProperty read _REFERENCED_BY_FRAGMENT_SHADER;
public static property REFERENCED_BY_COMPUTE_SHADER: ProgramResourceProperty read _REFERENCED_BY_COMPUTE_SHADER;
public static property TOP_LEVEL_ARRAY_SIZE: ProgramResourceProperty read _TOP_LEVEL_ARRAY_SIZE;
public static property TOP_LEVEL_ARRAY_STRIDE: ProgramResourceProperty read _TOP_LEVEL_ARRAY_STRIDE;
public static property LOCATION: ProgramResourceProperty read _LOCATION;
public static property LOCATION_INDEX: ProgramResourceProperty read _LOCATION_INDEX;
public static property LOCATION_COMPONENT: ProgramResourceProperty read _LOCATION_COMPONENT;
public static property TRANSFORM_FEEDBACK_BUFFER_INDEX: ProgramResourceProperty read _TRANSFORM_FEEDBACK_BUFFER_INDEX;
public static property TRANSFORM_FEEDBACK_BUFFER_STRIDE: ProgramResourceProperty read _TRANSFORM_FEEDBACK_BUFFER_STRIDE;
public function ToString: string; override;
begin
if self.val = UInt32($8E4A) then Result := 'NUM_COMPATIBLE_SUBROUTINES' else
if self.val = UInt32($8E4B) then Result := 'COMPATIBLE_SUBROUTINES' else
if self.val = UInt32($92E1) then Result := 'UNIFORM' else
if self.val = UInt32($92E7) then Result := 'IS_PER_PATCH' else
if self.val = UInt32($92F9) then Result := 'NAME_LENGTH' else
if self.val = UInt32($92FA) then Result := 'TYPE' else
if self.val = UInt32($92FB) then Result := 'ARRAY_SIZE' else
if self.val = UInt32($92FC) then Result := 'OFFSET' else
if self.val = UInt32($92FD) then Result := 'BLOCK_INDEX' else
if self.val = UInt32($92FE) then Result := 'ARRAY_STRIDE' else
if self.val = UInt32($92FF) then Result := 'MATRIX_STRIDE' else
if self.val = UInt32($9300) then Result := 'IS_ROW_MAJOR' else
if self.val = UInt32($9301) then Result := 'ATOMIC_COUNTER_BUFFER_INDEX' else
if self.val = UInt32($9302) then Result := 'BUFFER_BINDING' else
if self.val = UInt32($9303) then Result := 'BUFFER_DATA_SIZE' else
if self.val = UInt32($9304) then Result := 'NUM_ACTIVE_VARIABLES' else
if self.val = UInt32($9305) then Result := 'ACTIVE_VARIABLES' else
if self.val = UInt32($9306) then Result := 'REFERENCED_BY_VERTEX_SHADER' else
if self.val = UInt32($9307) then Result := 'REFERENCED_BY_TESS_CONTROL_SHADER' else
if self.val = UInt32($9308) then Result := 'REFERENCED_BY_TESS_EVALUATION_SHADER' else
if self.val = UInt32($9309) then Result := 'REFERENCED_BY_GEOMETRY_SHADER' else
if self.val = UInt32($930A) then Result := 'REFERENCED_BY_FRAGMENT_SHADER' else
if self.val = UInt32($930B) then Result := 'REFERENCED_BY_COMPUTE_SHADER' else
if self.val = UInt32($930C) then Result := 'TOP_LEVEL_ARRAY_SIZE' else
if self.val = UInt32($930D) then Result := 'TOP_LEVEL_ARRAY_STRIDE' else
if self.val = UInt32($930E) then Result := 'LOCATION' else
if self.val = UInt32($930F) then Result := 'LOCATION_INDEX' else
if self.val = UInt32($934A) then Result := 'LOCATION_COMPONENT' else
if self.val = UInt32($934B) then Result := 'TRANSFORM_FEEDBACK_BUFFER_INDEX' else
if self.val = UInt32($934C) then Result := 'TRANSFORM_FEEDBACK_BUFFER_STRIDE' else
Result := self.val.ToString;
end;
end;
ProgramStagePName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ACTIVE_SUBROUTINES := new ProgramStagePName($8DE5);
private static _ACTIVE_SUBROUTINE_UNIFORMS := new ProgramStagePName($8DE6);
private static _ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS := new ProgramStagePName($8E47);
private static _ACTIVE_SUBROUTINE_MAX_LENGTH := new ProgramStagePName($8E48);
private static _ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH := new ProgramStagePName($8E49);
public static property ACTIVE_SUBROUTINES: ProgramStagePName read _ACTIVE_SUBROUTINES;
public static property ACTIVE_SUBROUTINE_UNIFORMS: ProgramStagePName read _ACTIVE_SUBROUTINE_UNIFORMS;
public static property ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS: ProgramStagePName read _ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS;
public static property ACTIVE_SUBROUTINE_MAX_LENGTH: ProgramStagePName read _ACTIVE_SUBROUTINE_MAX_LENGTH;
public static property ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH: ProgramStagePName read _ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH;
public function ToString: string; override;
begin
if self.val = UInt32($8DE5) then Result := 'ACTIVE_SUBROUTINES' else
if self.val = UInt32($8DE6) then Result := 'ACTIVE_SUBROUTINE_UNIFORMS' else
if self.val = UInt32($8E47) then Result := 'ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS' else
if self.val = UInt32($8E48) then Result := 'ACTIVE_SUBROUTINE_MAX_LENGTH' else
if self.val = UInt32($8E49) then Result := 'ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH' else
Result := self.val.ToString;
end;
end;
ProgramStringProperty = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PROGRAM_STRING_ARB := new ProgramStringProperty($8628);
public static property PROGRAM_STRING_ARB: ProgramStringProperty read _PROGRAM_STRING_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($8628) then Result := 'PROGRAM_STRING_ARB' else
Result := self.val.ToString;
end;
end;
ProgramTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXT_FRAGMENT_SHADER_ATI := new ProgramTarget($8200);
private static _VERTEX_PROGRAM_ARB := new ProgramTarget($8620);
private static _FRAGMENT_PROGRAM_ARB := new ProgramTarget($8804);
private static _TESS_CONTROL_PROGRAM_NV := new ProgramTarget($891E);
private static _TESS_EVALUATION_PROGRAM_NV := new ProgramTarget($891F);
private static _GEOMETRY_PROGRAM_NV := new ProgramTarget($8C26);
private static _COMPUTE_PROGRAM_NV := new ProgramTarget($90FB);
public static property TEXT_FRAGMENT_SHADER_ATI: ProgramTarget read _TEXT_FRAGMENT_SHADER_ATI;
public static property VERTEX_PROGRAM_ARB: ProgramTarget read _VERTEX_PROGRAM_ARB;
public static property FRAGMENT_PROGRAM_ARB: ProgramTarget read _FRAGMENT_PROGRAM_ARB;
public static property TESS_CONTROL_PROGRAM_NV: ProgramTarget read _TESS_CONTROL_PROGRAM_NV;
public static property TESS_EVALUATION_PROGRAM_NV: ProgramTarget read _TESS_EVALUATION_PROGRAM_NV;
public static property GEOMETRY_PROGRAM_NV: ProgramTarget read _GEOMETRY_PROGRAM_NV;
public static property COMPUTE_PROGRAM_NV: ProgramTarget read _COMPUTE_PROGRAM_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8200) then Result := 'TEXT_FRAGMENT_SHADER_ATI' else
if self.val = UInt32($8620) then Result := 'VERTEX_PROGRAM_ARB' else
if self.val = UInt32($8804) then Result := 'FRAGMENT_PROGRAM_ARB' else
if self.val = UInt32($891E) then Result := 'TESS_CONTROL_PROGRAM_NV' else
if self.val = UInt32($891F) then Result := 'TESS_EVALUATION_PROGRAM_NV' else
if self.val = UInt32($8C26) then Result := 'GEOMETRY_PROGRAM_NV' else
if self.val = UInt32($90FB) then Result := 'COMPUTE_PROGRAM_NV' else
Result := self.val.ToString;
end;
end;
QueryCounterTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TIMESTAMP := new QueryCounterTarget($8E28);
public static property TIMESTAMP: QueryCounterTarget read _TIMESTAMP;
public function ToString: string; override;
begin
if self.val = UInt32($8E28) then Result := 'TIMESTAMP' else
Result := self.val.ToString;
end;
end;
QueryObjectParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _QUERY_TARGET := new QueryObjectParameterName($82EA);
private static _QUERY_RESULT := new QueryObjectParameterName($8866);
private static _QUERY_RESULT_AVAILABLE := new QueryObjectParameterName($8867);
private static _QUERY_RESULT_NO_WAIT := new QueryObjectParameterName($9194);
public static property QUERY_TARGET: QueryObjectParameterName read _QUERY_TARGET;
public static property QUERY_RESULT: QueryObjectParameterName read _QUERY_RESULT;
public static property QUERY_RESULT_AVAILABLE: QueryObjectParameterName read _QUERY_RESULT_AVAILABLE;
public static property QUERY_RESULT_NO_WAIT: QueryObjectParameterName read _QUERY_RESULT_NO_WAIT;
public function ToString: string; override;
begin
if self.val = UInt32($82EA) then Result := 'QUERY_TARGET' else
if self.val = UInt32($8866) then Result := 'QUERY_RESULT' else
if self.val = UInt32($8867) then Result := 'QUERY_RESULT_AVAILABLE' else
if self.val = UInt32($9194) then Result := 'QUERY_RESULT_NO_WAIT' else
Result := self.val.ToString;
end;
end;
QueryParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _QUERY_COUNTER_BITS := new QueryParameterName($8864);
private static _CURRENT_QUERY := new QueryParameterName($8865);
public static property QUERY_COUNTER_BITS: QueryParameterName read _QUERY_COUNTER_BITS;
public static property CURRENT_QUERY: QueryParameterName read _CURRENT_QUERY;
public function ToString: string; override;
begin
if self.val = UInt32($8864) then Result := 'QUERY_COUNTER_BITS' else
if self.val = UInt32($8865) then Result := 'CURRENT_QUERY' else
Result := self.val.ToString;
end;
end;
QueryTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TRANSFORM_FEEDBACK_OVERFLOW := new QueryTarget($82EC);
private static _VERTICES_SUBMITTED := new QueryTarget($82EE);
private static _PRIMITIVES_SUBMITTED := new QueryTarget($82EF);
private static _VERTEX_SHADER_INVOCATIONS := new QueryTarget($82F0);
private static _TIME_ELAPSED := new QueryTarget($88BF);
private static _SAMPLES_PASSED := new QueryTarget($8914);
private static _ANY_SAMPLES_PASSED := new QueryTarget($8C2F);
private static _PRIMITIVES_GENERATED := new QueryTarget($8C87);
private static _TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN := new QueryTarget($8C88);
private static _ANY_SAMPLES_PASSED_CONSERVATIVE := new QueryTarget($8D6A);
public static property TRANSFORM_FEEDBACK_OVERFLOW: QueryTarget read _TRANSFORM_FEEDBACK_OVERFLOW;
public static property VERTICES_SUBMITTED: QueryTarget read _VERTICES_SUBMITTED;
public static property PRIMITIVES_SUBMITTED: QueryTarget read _PRIMITIVES_SUBMITTED;
public static property VERTEX_SHADER_INVOCATIONS: QueryTarget read _VERTEX_SHADER_INVOCATIONS;
public static property TIME_ELAPSED: QueryTarget read _TIME_ELAPSED;
public static property SAMPLES_PASSED: QueryTarget read _SAMPLES_PASSED;
public static property ANY_SAMPLES_PASSED: QueryTarget read _ANY_SAMPLES_PASSED;
public static property PRIMITIVES_GENERATED: QueryTarget read _PRIMITIVES_GENERATED;
public static property TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: QueryTarget read _TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
public static property ANY_SAMPLES_PASSED_CONSERVATIVE: QueryTarget read _ANY_SAMPLES_PASSED_CONSERVATIVE;
public function ToString: string; override;
begin
if self.val = UInt32($82EC) then Result := 'TRANSFORM_FEEDBACK_OVERFLOW' else
if self.val = UInt32($82EE) then Result := 'VERTICES_SUBMITTED' else
if self.val = UInt32($82EF) then Result := 'PRIMITIVES_SUBMITTED' else
if self.val = UInt32($82F0) then Result := 'VERTEX_SHADER_INVOCATIONS' else
if self.val = UInt32($88BF) then Result := 'TIME_ELAPSED' else
if self.val = UInt32($8914) then Result := 'SAMPLES_PASSED' else
if self.val = UInt32($8C2F) then Result := 'ANY_SAMPLES_PASSED' else
if self.val = UInt32($8C87) then Result := 'PRIMITIVES_GENERATED' else
if self.val = UInt32($8C88) then Result := 'TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN' else
if self.val = UInt32($8D6A) then Result := 'ANY_SAMPLES_PASSED_CONSERVATIVE' else
Result := self.val.ToString;
end;
end;
ReadBufferMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new ReadBufferMode($0000);
private static _NONE_OES := new ReadBufferMode($0000);
private static _FRONT_LEFT := new ReadBufferMode($0400);
private static _FRONT_RIGHT := new ReadBufferMode($0401);
private static _BACK_LEFT := new ReadBufferMode($0402);
private static _BACK_RIGHT := new ReadBufferMode($0403);
private static _FRONT := new ReadBufferMode($0404);
private static _BACK := new ReadBufferMode($0405);
private static _LEFT := new ReadBufferMode($0406);
private static _RIGHT := new ReadBufferMode($0407);
private static _AUX0 := new ReadBufferMode($0409);
private static _AUX1 := new ReadBufferMode($040A);
private static _AUX2 := new ReadBufferMode($040B);
private static _AUX3 := new ReadBufferMode($040C);
private static _COLOR_ATTACHMENT0 := new ReadBufferMode($8CE0);
private static _COLOR_ATTACHMENT1 := new ReadBufferMode($8CE1);
private static _COLOR_ATTACHMENT2 := new ReadBufferMode($8CE2);
private static _COLOR_ATTACHMENT3 := new ReadBufferMode($8CE3);
private static _COLOR_ATTACHMENT4 := new ReadBufferMode($8CE4);
private static _COLOR_ATTACHMENT5 := new ReadBufferMode($8CE5);
private static _COLOR_ATTACHMENT6 := new ReadBufferMode($8CE6);
private static _COLOR_ATTACHMENT7 := new ReadBufferMode($8CE7);
private static _COLOR_ATTACHMENT8 := new ReadBufferMode($8CE8);
private static _COLOR_ATTACHMENT9 := new ReadBufferMode($8CE9);
private static _COLOR_ATTACHMENT10 := new ReadBufferMode($8CEA);
private static _COLOR_ATTACHMENT11 := new ReadBufferMode($8CEB);
private static _COLOR_ATTACHMENT12 := new ReadBufferMode($8CEC);
private static _COLOR_ATTACHMENT13 := new ReadBufferMode($8CED);
private static _COLOR_ATTACHMENT14 := new ReadBufferMode($8CEE);
private static _COLOR_ATTACHMENT15 := new ReadBufferMode($8CEF);
public static property NONE: ReadBufferMode read _NONE;
public static property NONE_OES: ReadBufferMode read _NONE_OES;
public static property FRONT_LEFT: ReadBufferMode read _FRONT_LEFT;
public static property FRONT_RIGHT: ReadBufferMode read _FRONT_RIGHT;
public static property BACK_LEFT: ReadBufferMode read _BACK_LEFT;
public static property BACK_RIGHT: ReadBufferMode read _BACK_RIGHT;
public static property FRONT: ReadBufferMode read _FRONT;
public static property BACK: ReadBufferMode read _BACK;
public static property LEFT: ReadBufferMode read _LEFT;
public static property RIGHT: ReadBufferMode read _RIGHT;
public static property AUX0: ReadBufferMode read _AUX0;
public static property AUX1: ReadBufferMode read _AUX1;
public static property AUX2: ReadBufferMode read _AUX2;
public static property AUX3: ReadBufferMode read _AUX3;
public static property COLOR_ATTACHMENT0: ReadBufferMode read _COLOR_ATTACHMENT0;
public static property COLOR_ATTACHMENT1: ReadBufferMode read _COLOR_ATTACHMENT1;
public static property COLOR_ATTACHMENT2: ReadBufferMode read _COLOR_ATTACHMENT2;
public static property COLOR_ATTACHMENT3: ReadBufferMode read _COLOR_ATTACHMENT3;
public static property COLOR_ATTACHMENT4: ReadBufferMode read _COLOR_ATTACHMENT4;
public static property COLOR_ATTACHMENT5: ReadBufferMode read _COLOR_ATTACHMENT5;
public static property COLOR_ATTACHMENT6: ReadBufferMode read _COLOR_ATTACHMENT6;
public static property COLOR_ATTACHMENT7: ReadBufferMode read _COLOR_ATTACHMENT7;
public static property COLOR_ATTACHMENT8: ReadBufferMode read _COLOR_ATTACHMENT8;
public static property COLOR_ATTACHMENT9: ReadBufferMode read _COLOR_ATTACHMENT9;
public static property COLOR_ATTACHMENT10: ReadBufferMode read _COLOR_ATTACHMENT10;
public static property COLOR_ATTACHMENT11: ReadBufferMode read _COLOR_ATTACHMENT11;
public static property COLOR_ATTACHMENT12: ReadBufferMode read _COLOR_ATTACHMENT12;
public static property COLOR_ATTACHMENT13: ReadBufferMode read _COLOR_ATTACHMENT13;
public static property COLOR_ATTACHMENT14: ReadBufferMode read _COLOR_ATTACHMENT14;
public static property COLOR_ATTACHMENT15: ReadBufferMode read _COLOR_ATTACHMENT15;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($0000) then Result := 'NONE_OES' else
if self.val = UInt32($0400) then Result := 'FRONT_LEFT' else
if self.val = UInt32($0401) then Result := 'FRONT_RIGHT' else
if self.val = UInt32($0402) then Result := 'BACK_LEFT' else
if self.val = UInt32($0403) then Result := 'BACK_RIGHT' else
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0406) then Result := 'LEFT' else
if self.val = UInt32($0407) then Result := 'RIGHT' else
if self.val = UInt32($0409) then Result := 'AUX0' else
if self.val = UInt32($040A) then Result := 'AUX1' else
if self.val = UInt32($040B) then Result := 'AUX2' else
if self.val = UInt32($040C) then Result := 'AUX3' else
if self.val = UInt32($8CE0) then Result := 'COLOR_ATTACHMENT0' else
if self.val = UInt32($8CE1) then Result := 'COLOR_ATTACHMENT1' else
if self.val = UInt32($8CE2) then Result := 'COLOR_ATTACHMENT2' else
if self.val = UInt32($8CE3) then Result := 'COLOR_ATTACHMENT3' else
if self.val = UInt32($8CE4) then Result := 'COLOR_ATTACHMENT4' else
if self.val = UInt32($8CE5) then Result := 'COLOR_ATTACHMENT5' else
if self.val = UInt32($8CE6) then Result := 'COLOR_ATTACHMENT6' else
if self.val = UInt32($8CE7) then Result := 'COLOR_ATTACHMENT7' else
if self.val = UInt32($8CE8) then Result := 'COLOR_ATTACHMENT8' else
if self.val = UInt32($8CE9) then Result := 'COLOR_ATTACHMENT9' else
if self.val = UInt32($8CEA) then Result := 'COLOR_ATTACHMENT10' else
if self.val = UInt32($8CEB) then Result := 'COLOR_ATTACHMENT11' else
if self.val = UInt32($8CEC) then Result := 'COLOR_ATTACHMENT12' else
if self.val = UInt32($8CED) then Result := 'COLOR_ATTACHMENT13' else
if self.val = UInt32($8CEE) then Result := 'COLOR_ATTACHMENT14' else
if self.val = UInt32($8CEF) then Result := 'COLOR_ATTACHMENT15' else
Result := self.val.ToString;
end;
end;
RenderbufferParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _RENDERBUFFER_COVERAGE_SAMPLES_NV := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_SAMPLES := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_SAMPLES_ANGLE := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_SAMPLES_APPLE := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_SAMPLES_EXT := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_SAMPLES_NV := new RenderbufferParameterName($8CAB);
private static _RENDERBUFFER_WIDTH := new RenderbufferParameterName($8D42);
private static _RENDERBUFFER_WIDTH_EXT := new RenderbufferParameterName($8D42);
private static _RENDERBUFFER_WIDTH_OES := new RenderbufferParameterName($8D42);
private static _RENDERBUFFER_HEIGHT := new RenderbufferParameterName($8D43);
private static _RENDERBUFFER_HEIGHT_EXT := new RenderbufferParameterName($8D43);
private static _RENDERBUFFER_HEIGHT_OES := new RenderbufferParameterName($8D43);
private static _RENDERBUFFER_INTERNAL_FORMAT := new RenderbufferParameterName($8D44);
private static _RENDERBUFFER_INTERNAL_FORMAT_EXT := new RenderbufferParameterName($8D44);
private static _RENDERBUFFER_INTERNAL_FORMAT_OES := new RenderbufferParameterName($8D44);
private static _RENDERBUFFER_RED_SIZE := new RenderbufferParameterName($8D50);
private static _RENDERBUFFER_RED_SIZE_EXT := new RenderbufferParameterName($8D50);
private static _RENDERBUFFER_RED_SIZE_OES := new RenderbufferParameterName($8D50);
private static _RENDERBUFFER_GREEN_SIZE := new RenderbufferParameterName($8D51);
private static _RENDERBUFFER_GREEN_SIZE_EXT := new RenderbufferParameterName($8D51);
private static _RENDERBUFFER_GREEN_SIZE_OES := new RenderbufferParameterName($8D51);
private static _RENDERBUFFER_BLUE_SIZE := new RenderbufferParameterName($8D52);
private static _RENDERBUFFER_BLUE_SIZE_EXT := new RenderbufferParameterName($8D52);
private static _RENDERBUFFER_BLUE_SIZE_OES := new RenderbufferParameterName($8D52);
private static _RENDERBUFFER_ALPHA_SIZE := new RenderbufferParameterName($8D53);
private static _RENDERBUFFER_ALPHA_SIZE_EXT := new RenderbufferParameterName($8D53);
private static _RENDERBUFFER_ALPHA_SIZE_OES := new RenderbufferParameterName($8D53);
private static _RENDERBUFFER_DEPTH_SIZE := new RenderbufferParameterName($8D54);
private static _RENDERBUFFER_DEPTH_SIZE_EXT := new RenderbufferParameterName($8D54);
private static _RENDERBUFFER_DEPTH_SIZE_OES := new RenderbufferParameterName($8D54);
private static _RENDERBUFFER_STENCIL_SIZE := new RenderbufferParameterName($8D55);
private static _RENDERBUFFER_STENCIL_SIZE_EXT := new RenderbufferParameterName($8D55);
private static _RENDERBUFFER_STENCIL_SIZE_OES := new RenderbufferParameterName($8D55);
private static _RENDERBUFFER_COLOR_SAMPLES_NV := new RenderbufferParameterName($8E10);
private static _RENDERBUFFER_SAMPLES_IMG := new RenderbufferParameterName($9133);
private static _RENDERBUFFER_STORAGE_SAMPLES_AMD := new RenderbufferParameterName($91B2);
public static property RENDERBUFFER_COVERAGE_SAMPLES_NV: RenderbufferParameterName read _RENDERBUFFER_COVERAGE_SAMPLES_NV;
public static property RENDERBUFFER_SAMPLES: RenderbufferParameterName read _RENDERBUFFER_SAMPLES;
public static property RENDERBUFFER_SAMPLES_ANGLE: RenderbufferParameterName read _RENDERBUFFER_SAMPLES_ANGLE;
public static property RENDERBUFFER_SAMPLES_APPLE: RenderbufferParameterName read _RENDERBUFFER_SAMPLES_APPLE;
public static property RENDERBUFFER_SAMPLES_EXT: RenderbufferParameterName read _RENDERBUFFER_SAMPLES_EXT;
public static property RENDERBUFFER_SAMPLES_NV: RenderbufferParameterName read _RENDERBUFFER_SAMPLES_NV;
public static property RENDERBUFFER_WIDTH: RenderbufferParameterName read _RENDERBUFFER_WIDTH;
public static property RENDERBUFFER_WIDTH_EXT: RenderbufferParameterName read _RENDERBUFFER_WIDTH_EXT;
public static property RENDERBUFFER_WIDTH_OES: RenderbufferParameterName read _RENDERBUFFER_WIDTH_OES;
public static property RENDERBUFFER_HEIGHT: RenderbufferParameterName read _RENDERBUFFER_HEIGHT;
public static property RENDERBUFFER_HEIGHT_EXT: RenderbufferParameterName read _RENDERBUFFER_HEIGHT_EXT;
public static property RENDERBUFFER_HEIGHT_OES: RenderbufferParameterName read _RENDERBUFFER_HEIGHT_OES;
public static property RENDERBUFFER_INTERNAL_FORMAT: RenderbufferParameterName read _RENDERBUFFER_INTERNAL_FORMAT;
public static property RENDERBUFFER_INTERNAL_FORMAT_EXT: RenderbufferParameterName read _RENDERBUFFER_INTERNAL_FORMAT_EXT;
public static property RENDERBUFFER_INTERNAL_FORMAT_OES: RenderbufferParameterName read _RENDERBUFFER_INTERNAL_FORMAT_OES;
public static property RENDERBUFFER_RED_SIZE: RenderbufferParameterName read _RENDERBUFFER_RED_SIZE;
public static property RENDERBUFFER_RED_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_RED_SIZE_EXT;
public static property RENDERBUFFER_RED_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_RED_SIZE_OES;
public static property RENDERBUFFER_GREEN_SIZE: RenderbufferParameterName read _RENDERBUFFER_GREEN_SIZE;
public static property RENDERBUFFER_GREEN_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_GREEN_SIZE_EXT;
public static property RENDERBUFFER_GREEN_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_GREEN_SIZE_OES;
public static property RENDERBUFFER_BLUE_SIZE: RenderbufferParameterName read _RENDERBUFFER_BLUE_SIZE;
public static property RENDERBUFFER_BLUE_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_BLUE_SIZE_EXT;
public static property RENDERBUFFER_BLUE_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_BLUE_SIZE_OES;
public static property RENDERBUFFER_ALPHA_SIZE: RenderbufferParameterName read _RENDERBUFFER_ALPHA_SIZE;
public static property RENDERBUFFER_ALPHA_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_ALPHA_SIZE_EXT;
public static property RENDERBUFFER_ALPHA_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_ALPHA_SIZE_OES;
public static property RENDERBUFFER_DEPTH_SIZE: RenderbufferParameterName read _RENDERBUFFER_DEPTH_SIZE;
public static property RENDERBUFFER_DEPTH_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_DEPTH_SIZE_EXT;
public static property RENDERBUFFER_DEPTH_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_DEPTH_SIZE_OES;
public static property RENDERBUFFER_STENCIL_SIZE: RenderbufferParameterName read _RENDERBUFFER_STENCIL_SIZE;
public static property RENDERBUFFER_STENCIL_SIZE_EXT: RenderbufferParameterName read _RENDERBUFFER_STENCIL_SIZE_EXT;
public static property RENDERBUFFER_STENCIL_SIZE_OES: RenderbufferParameterName read _RENDERBUFFER_STENCIL_SIZE_OES;
public static property RENDERBUFFER_COLOR_SAMPLES_NV: RenderbufferParameterName read _RENDERBUFFER_COLOR_SAMPLES_NV;
public static property RENDERBUFFER_SAMPLES_IMG: RenderbufferParameterName read _RENDERBUFFER_SAMPLES_IMG;
public static property RENDERBUFFER_STORAGE_SAMPLES_AMD: RenderbufferParameterName read _RENDERBUFFER_STORAGE_SAMPLES_AMD;
public function ToString: string; override;
begin
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_COVERAGE_SAMPLES_NV' else
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_SAMPLES' else
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_SAMPLES_ANGLE' else
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_SAMPLES_APPLE' else
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_SAMPLES_EXT' else
if self.val = UInt32($8CAB) then Result := 'RENDERBUFFER_SAMPLES_NV' else
if self.val = UInt32($8D42) then Result := 'RENDERBUFFER_WIDTH' else
if self.val = UInt32($8D42) then Result := 'RENDERBUFFER_WIDTH_EXT' else
if self.val = UInt32($8D42) then Result := 'RENDERBUFFER_WIDTH_OES' else
if self.val = UInt32($8D43) then Result := 'RENDERBUFFER_HEIGHT' else
if self.val = UInt32($8D43) then Result := 'RENDERBUFFER_HEIGHT_EXT' else
if self.val = UInt32($8D43) then Result := 'RENDERBUFFER_HEIGHT_OES' else
if self.val = UInt32($8D44) then Result := 'RENDERBUFFER_INTERNAL_FORMAT' else
if self.val = UInt32($8D44) then Result := 'RENDERBUFFER_INTERNAL_FORMAT_EXT' else
if self.val = UInt32($8D44) then Result := 'RENDERBUFFER_INTERNAL_FORMAT_OES' else
if self.val = UInt32($8D50) then Result := 'RENDERBUFFER_RED_SIZE' else
if self.val = UInt32($8D50) then Result := 'RENDERBUFFER_RED_SIZE_EXT' else
if self.val = UInt32($8D50) then Result := 'RENDERBUFFER_RED_SIZE_OES' else
if self.val = UInt32($8D51) then Result := 'RENDERBUFFER_GREEN_SIZE' else
if self.val = UInt32($8D51) then Result := 'RENDERBUFFER_GREEN_SIZE_EXT' else
if self.val = UInt32($8D51) then Result := 'RENDERBUFFER_GREEN_SIZE_OES' else
if self.val = UInt32($8D52) then Result := 'RENDERBUFFER_BLUE_SIZE' else
if self.val = UInt32($8D52) then Result := 'RENDERBUFFER_BLUE_SIZE_EXT' else
if self.val = UInt32($8D52) then Result := 'RENDERBUFFER_BLUE_SIZE_OES' else
if self.val = UInt32($8D53) then Result := 'RENDERBUFFER_ALPHA_SIZE' else
if self.val = UInt32($8D53) then Result := 'RENDERBUFFER_ALPHA_SIZE_EXT' else
if self.val = UInt32($8D53) then Result := 'RENDERBUFFER_ALPHA_SIZE_OES' else
if self.val = UInt32($8D54) then Result := 'RENDERBUFFER_DEPTH_SIZE' else
if self.val = UInt32($8D54) then Result := 'RENDERBUFFER_DEPTH_SIZE_EXT' else
if self.val = UInt32($8D54) then Result := 'RENDERBUFFER_DEPTH_SIZE_OES' else
if self.val = UInt32($8D55) then Result := 'RENDERBUFFER_STENCIL_SIZE' else
if self.val = UInt32($8D55) then Result := 'RENDERBUFFER_STENCIL_SIZE_EXT' else
if self.val = UInt32($8D55) then Result := 'RENDERBUFFER_STENCIL_SIZE_OES' else
if self.val = UInt32($8E10) then Result := 'RENDERBUFFER_COLOR_SAMPLES_NV' else
if self.val = UInt32($9133) then Result := 'RENDERBUFFER_SAMPLES_IMG' else
if self.val = UInt32($91B2) then Result := 'RENDERBUFFER_STORAGE_SAMPLES_AMD' else
Result := self.val.ToString;
end;
end;
RenderbufferTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _RENDERBUFFER := new RenderbufferTarget($8D41);
private static _RENDERBUFFER_OES := new RenderbufferTarget($8D41);
public static property RENDERBUFFER: RenderbufferTarget read _RENDERBUFFER;
public static property RENDERBUFFER_OES: RenderbufferTarget read _RENDERBUFFER_OES;
public function ToString: string; override;
begin
if self.val = UInt32($8D41) then Result := 'RENDERBUFFER' else
if self.val = UInt32($8D41) then Result := 'RENDERBUFFER_OES' else
Result := self.val.ToString;
end;
end;
RenderingMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _RENDER := new RenderingMode($1C00);
private static _FEEDBACK := new RenderingMode($1C01);
private static _SELECT := new RenderingMode($1C02);
public static property RENDER: RenderingMode read _RENDER;
public static property FEEDBACK: RenderingMode read _FEEDBACK;
public static property SELECT: RenderingMode read _SELECT;
public function ToString: string; override;
begin
if self.val = UInt32($1C00) then Result := 'RENDER' else
if self.val = UInt32($1C01) then Result := 'FEEDBACK' else
if self.val = UInt32($1C02) then Result := 'SELECT' else
Result := self.val.ToString;
end;
end;
SamplerParameterF = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_BORDER_COLOR := new SamplerParameterF($1004);
private static _TEXTURE_MIN_LOD := new SamplerParameterF($813A);
private static _TEXTURE_MAX_LOD := new SamplerParameterF($813B);
private static _TEXTURE_MAX_ANISOTROPY := new SamplerParameterF($84FE);
private static _TEXTURE_UNNORMALIZED_COORDINATES_ARM := new SamplerParameterF($8F6A);
public static property TEXTURE_BORDER_COLOR: SamplerParameterF read _TEXTURE_BORDER_COLOR;
public static property TEXTURE_MIN_LOD: SamplerParameterF read _TEXTURE_MIN_LOD;
public static property TEXTURE_MAX_LOD: SamplerParameterF read _TEXTURE_MAX_LOD;
public static property TEXTURE_MAX_ANISOTROPY: SamplerParameterF read _TEXTURE_MAX_ANISOTROPY;
public static property TEXTURE_UNNORMALIZED_COORDINATES_ARM: SamplerParameterF read _TEXTURE_UNNORMALIZED_COORDINATES_ARM;
public function ToString: string; override;
begin
if self.val = UInt32($1004) then Result := 'TEXTURE_BORDER_COLOR' else
if self.val = UInt32($813A) then Result := 'TEXTURE_MIN_LOD' else
if self.val = UInt32($813B) then Result := 'TEXTURE_MAX_LOD' else
if self.val = UInt32($84FE) then Result := 'TEXTURE_MAX_ANISOTROPY' else
if self.val = UInt32($8F6A) then Result := 'TEXTURE_UNNORMALIZED_COORDINATES_ARM' else
Result := self.val.ToString;
end;
end;
SamplerParameterI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_MAG_FILTER := new SamplerParameterI($2800);
private static _TEXTURE_MIN_FILTER := new SamplerParameterI($2801);
private static _TEXTURE_WRAP_S := new SamplerParameterI($2802);
private static _TEXTURE_WRAP_T := new SamplerParameterI($2803);
private static _TEXTURE_WRAP_R := new SamplerParameterI($8072);
private static _TEXTURE_COMPARE_MODE := new SamplerParameterI($884C);
private static _TEXTURE_COMPARE_FUNC := new SamplerParameterI($884D);
private static _TEXTURE_UNNORMALIZED_COORDINATES_ARM := new SamplerParameterI($8F6A);
public static property TEXTURE_MAG_FILTER: SamplerParameterI read _TEXTURE_MAG_FILTER;
public static property TEXTURE_MIN_FILTER: SamplerParameterI read _TEXTURE_MIN_FILTER;
public static property TEXTURE_WRAP_S: SamplerParameterI read _TEXTURE_WRAP_S;
public static property TEXTURE_WRAP_T: SamplerParameterI read _TEXTURE_WRAP_T;
public static property TEXTURE_WRAP_R: SamplerParameterI read _TEXTURE_WRAP_R;
public static property TEXTURE_COMPARE_MODE: SamplerParameterI read _TEXTURE_COMPARE_MODE;
public static property TEXTURE_COMPARE_FUNC: SamplerParameterI read _TEXTURE_COMPARE_FUNC;
public static property TEXTURE_UNNORMALIZED_COORDINATES_ARM: SamplerParameterI read _TEXTURE_UNNORMALIZED_COORDINATES_ARM;
public function ToString: string; override;
begin
if self.val = UInt32($2800) then Result := 'TEXTURE_MAG_FILTER' else
if self.val = UInt32($2801) then Result := 'TEXTURE_MIN_FILTER' else
if self.val = UInt32($2802) then Result := 'TEXTURE_WRAP_S' else
if self.val = UInt32($2803) then Result := 'TEXTURE_WRAP_T' else
if self.val = UInt32($8072) then Result := 'TEXTURE_WRAP_R' else
if self.val = UInt32($884C) then Result := 'TEXTURE_COMPARE_MODE' else
if self.val = UInt32($884D) then Result := 'TEXTURE_COMPARE_FUNC' else
if self.val = UInt32($8F6A) then Result := 'TEXTURE_UNNORMALIZED_COORDINATES_ARM' else
Result := self.val.ToString;
end;
end;
ScalarType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_BYTE := new ScalarType($1401);
private static _UNSIGNED_SHORT := new ScalarType($1403);
private static _UNSIGNED_INT := new ScalarType($1405);
public static property UNSIGNED_BYTE: ScalarType read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: ScalarType read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: ScalarType read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
SemaphoreParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _D3D12_FENCE_VALUE_EXT := new SemaphoreParameterName($9595);
public static property D3D12_FENCE_VALUE_EXT: SemaphoreParameterName read _D3D12_FENCE_VALUE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($9595) then Result := 'D3D12_FENCE_VALUE_EXT' else
Result := self.val.ToString;
end;
end;
ShaderParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SHADER_TYPE := new ShaderParameterName($8B4F);
private static _DELETE_STATUS := new ShaderParameterName($8B80);
private static _COMPILE_STATUS := new ShaderParameterName($8B81);
private static _INFO_LOG_LENGTH := new ShaderParameterName($8B84);
private static _SHADER_SOURCE_LENGTH := new ShaderParameterName($8B88);
public static property SHADER_TYPE: ShaderParameterName read _SHADER_TYPE;
public static property DELETE_STATUS: ShaderParameterName read _DELETE_STATUS;
public static property COMPILE_STATUS: ShaderParameterName read _COMPILE_STATUS;
public static property INFO_LOG_LENGTH: ShaderParameterName read _INFO_LOG_LENGTH;
public static property SHADER_SOURCE_LENGTH: ShaderParameterName read _SHADER_SOURCE_LENGTH;
public function ToString: string; override;
begin
if self.val = UInt32($8B4F) then Result := 'SHADER_TYPE' else
if self.val = UInt32($8B80) then Result := 'DELETE_STATUS' else
if self.val = UInt32($8B81) then Result := 'COMPILE_STATUS' else
if self.val = UInt32($8B84) then Result := 'INFO_LOG_LENGTH' else
if self.val = UInt32($8B88) then Result := 'SHADER_SOURCE_LENGTH' else
Result := self.val.ToString;
end;
end;
ShaderType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAGMENT_SHADER := new ShaderType($8B30);
private static _FRAGMENT_SHADER_ARB := new ShaderType($8B30);
private static _VERTEX_SHADER := new ShaderType($8B31);
private static _VERTEX_SHADER_ARB := new ShaderType($8B31);
private static _GEOMETRY_SHADER := new ShaderType($8DD9);
private static _TESS_EVALUATION_SHADER := new ShaderType($8E87);
private static _TESS_CONTROL_SHADER := new ShaderType($8E88);
private static _COMPUTE_SHADER := new ShaderType($91B9);
public static property FRAGMENT_SHADER: ShaderType read _FRAGMENT_SHADER;
public static property FRAGMENT_SHADER_ARB: ShaderType read _FRAGMENT_SHADER_ARB;
public static property VERTEX_SHADER: ShaderType read _VERTEX_SHADER;
public static property VERTEX_SHADER_ARB: ShaderType read _VERTEX_SHADER_ARB;
public static property GEOMETRY_SHADER: ShaderType read _GEOMETRY_SHADER;
public static property TESS_EVALUATION_SHADER: ShaderType read _TESS_EVALUATION_SHADER;
public static property TESS_CONTROL_SHADER: ShaderType read _TESS_CONTROL_SHADER;
public static property COMPUTE_SHADER: ShaderType read _COMPUTE_SHADER;
public function ToString: string; override;
begin
if self.val = UInt32($8B30) then Result := 'FRAGMENT_SHADER' else
if self.val = UInt32($8B30) then Result := 'FRAGMENT_SHADER_ARB' else
if self.val = UInt32($8B31) then Result := 'VERTEX_SHADER' else
if self.val = UInt32($8B31) then Result := 'VERTEX_SHADER_ARB' else
if self.val = UInt32($8DD9) then Result := 'GEOMETRY_SHADER' else
if self.val = UInt32($8E87) then Result := 'TESS_EVALUATION_SHADER' else
if self.val = UInt32($8E88) then Result := 'TESS_CONTROL_SHADER' else
if self.val = UInt32($91B9) then Result := 'COMPUTE_SHADER' else
Result := self.val.ToString;
end;
end;
ShadingModel = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLAT := new ShadingModel($1D00);
private static _SMOOTH := new ShadingModel($1D01);
public static property FLAT: ShadingModel read _FLAT;
public static property SMOOTH: ShadingModel read _SMOOTH;
public function ToString: string; override;
begin
if self.val = UInt32($1D00) then Result := 'FLAT' else
if self.val = UInt32($1D01) then Result := 'SMOOTH' else
Result := self.val.ToString;
end;
end;
StencilFaceDirection = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRONT := new StencilFaceDirection($0404);
private static _BACK := new StencilFaceDirection($0405);
private static _FRONT_AND_BACK := new StencilFaceDirection($0408);
public static property FRONT: StencilFaceDirection read _FRONT;
public static property BACK: StencilFaceDirection read _BACK;
public static property FRONT_AND_BACK: StencilFaceDirection read _FRONT_AND_BACK;
public function ToString: string; override;
begin
if self.val = UInt32($0404) then Result := 'FRONT' else
if self.val = UInt32($0405) then Result := 'BACK' else
if self.val = UInt32($0408) then Result := 'FRONT_AND_BACK' else
Result := self.val.ToString;
end;
end;
StencilFunction = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEVER := new StencilFunction($0200);
private static _LESS := new StencilFunction($0201);
private static _EQUAL := new StencilFunction($0202);
private static _LEQUAL := new StencilFunction($0203);
private static _GREATER := new StencilFunction($0204);
private static _NOTEQUAL := new StencilFunction($0205);
private static _GEQUAL := new StencilFunction($0206);
private static _ALWAYS := new StencilFunction($0207);
public static property NEVER: StencilFunction read _NEVER;
public static property LESS: StencilFunction read _LESS;
public static property EQUAL: StencilFunction read _EQUAL;
public static property LEQUAL: StencilFunction read _LEQUAL;
public static property GREATER: StencilFunction read _GREATER;
public static property NOTEQUAL: StencilFunction read _NOTEQUAL;
public static property GEQUAL: StencilFunction read _GEQUAL;
public static property ALWAYS: StencilFunction read _ALWAYS;
public function ToString: string; override;
begin
if self.val = UInt32($0200) then Result := 'NEVER' else
if self.val = UInt32($0201) then Result := 'LESS' else
if self.val = UInt32($0202) then Result := 'EQUAL' else
if self.val = UInt32($0203) then Result := 'LEQUAL' else
if self.val = UInt32($0204) then Result := 'GREATER' else
if self.val = UInt32($0205) then Result := 'NOTEQUAL' else
if self.val = UInt32($0206) then Result := 'GEQUAL' else
if self.val = UInt32($0207) then Result := 'ALWAYS' else
Result := self.val.ToString;
end;
end;
StencilOp = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ZERO := new StencilOp($0000);
private static _INVERT := new StencilOp($150A);
private static _KEEP := new StencilOp($1E00);
private static _REPLACE := new StencilOp($1E01);
private static _INCR := new StencilOp($1E02);
private static _DECR := new StencilOp($1E03);
private static _INCR_WRAP := new StencilOp($8507);
private static _DECR_WRAP := new StencilOp($8508);
public static property ZERO: StencilOp read _ZERO;
public static property INVERT: StencilOp read _INVERT;
public static property KEEP: StencilOp read _KEEP;
public static property REPLACE: StencilOp read _REPLACE;
public static property INCR: StencilOp read _INCR;
public static property DECR: StencilOp read _DECR;
public static property INCR_WRAP: StencilOp read _INCR_WRAP;
public static property DECR_WRAP: StencilOp read _DECR_WRAP;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'ZERO' else
if self.val = UInt32($150A) then Result := 'INVERT' else
if self.val = UInt32($1E00) then Result := 'KEEP' else
if self.val = UInt32($1E01) then Result := 'REPLACE' else
if self.val = UInt32($1E02) then Result := 'INCR' else
if self.val = UInt32($1E03) then Result := 'DECR' else
if self.val = UInt32($8507) then Result := 'INCR_WRAP' else
if self.val = UInt32($8508) then Result := 'DECR_WRAP' else
Result := self.val.ToString;
end;
end;
StringName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VENDOR := new StringName($1F00);
private static _RENDERER := new StringName($1F01);
private static _VERSION := new StringName($1F02);
private static _EXTENSIONS := new StringName($1F03);
private static _SHADING_LANGUAGE_VERSION := new StringName($8B8C);
public static property VENDOR: StringName read _VENDOR;
public static property RENDERER: StringName read _RENDERER;
public static property VERSION: StringName read _VERSION;
public static property EXTENSIONS: StringName read _EXTENSIONS;
public static property SHADING_LANGUAGE_VERSION: StringName read _SHADING_LANGUAGE_VERSION;
public function ToString: string; override;
begin
if self.val = UInt32($1F00) then Result := 'VENDOR' else
if self.val = UInt32($1F01) then Result := 'RENDERER' else
if self.val = UInt32($1F02) then Result := 'VERSION' else
if self.val = UInt32($1F03) then Result := 'EXTENSIONS' else
if self.val = UInt32($8B8C) then Result := 'SHADING_LANGUAGE_VERSION' else
Result := self.val.ToString;
end;
end;
SubroutineParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNIFORM_SIZE := new SubroutineParameterName($8A38);
private static _UNIFORM_NAME_LENGTH := new SubroutineParameterName($8A39);
private static _NUM_COMPATIBLE_SUBROUTINES := new SubroutineParameterName($8E4A);
private static _COMPATIBLE_SUBROUTINES := new SubroutineParameterName($8E4B);
public static property UNIFORM_SIZE: SubroutineParameterName read _UNIFORM_SIZE;
public static property UNIFORM_NAME_LENGTH: SubroutineParameterName read _UNIFORM_NAME_LENGTH;
public static property NUM_COMPATIBLE_SUBROUTINES: SubroutineParameterName read _NUM_COMPATIBLE_SUBROUTINES;
public static property COMPATIBLE_SUBROUTINES: SubroutineParameterName read _COMPATIBLE_SUBROUTINES;
public function ToString: string; override;
begin
if self.val = UInt32($8A38) then Result := 'UNIFORM_SIZE' else
if self.val = UInt32($8A39) then Result := 'UNIFORM_NAME_LENGTH' else
if self.val = UInt32($8E4A) then Result := 'NUM_COMPATIBLE_SUBROUTINES' else
if self.val = UInt32($8E4B) then Result := 'COMPATIBLE_SUBROUTINES' else
Result := self.val.ToString;
end;
end;
SyncCondition = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SYNC_GPU_COMMANDS_COMPLETE := new SyncCondition($9117);
public static property SYNC_GPU_COMMANDS_COMPLETE: SyncCondition read _SYNC_GPU_COMMANDS_COMPLETE;
public function ToString: string; override;
begin
if self.val = UInt32($9117) then Result := 'SYNC_GPU_COMMANDS_COMPLETE' else
Result := self.val.ToString;
end;
end;
SyncObjectMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SYNC_FLUSH_COMMANDS_BIT := new SyncObjectMask($0001);
private static _SYNC_FLUSH_COMMANDS_BIT_APPLE := new SyncObjectMask($0001);
public static property SYNC_FLUSH_COMMANDS_BIT: SyncObjectMask read _SYNC_FLUSH_COMMANDS_BIT;
public static property SYNC_FLUSH_COMMANDS_BIT_APPLE: SyncObjectMask read _SYNC_FLUSH_COMMANDS_BIT_APPLE;
public static function operator or(f1,f2: SyncObjectMask) := new SyncObjectMask(f1.val or f2.val);
public property HAS_FLAG_SYNC_FLUSH_COMMANDS_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_SYNC_FLUSH_COMMANDS_BIT_APPLE: boolean read self.val and $0001 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'SYNC_FLUSH_COMMANDS_BIT+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'SYNC_FLUSH_COMMANDS_BIT_APPLE+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
SyncParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _OBJECT_TYPE := new SyncParameterName($9112);
private static _SYNC_CONDITION := new SyncParameterName($9113);
private static _SYNC_STATUS := new SyncParameterName($9114);
private static _SYNC_FLAGS := new SyncParameterName($9115);
public static property OBJECT_TYPE: SyncParameterName read _OBJECT_TYPE;
public static property SYNC_CONDITION: SyncParameterName read _SYNC_CONDITION;
public static property SYNC_STATUS: SyncParameterName read _SYNC_STATUS;
public static property SYNC_FLAGS: SyncParameterName read _SYNC_FLAGS;
public function ToString: string; override;
begin
if self.val = UInt32($9112) then Result := 'OBJECT_TYPE' else
if self.val = UInt32($9113) then Result := 'SYNC_CONDITION' else
if self.val = UInt32($9114) then Result := 'SYNC_STATUS' else
if self.val = UInt32($9115) then Result := 'SYNC_FLAGS' else
Result := self.val.ToString;
end;
end;
SyncStatus = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ALREADY_SIGNALED := new SyncStatus($911A);
private static _TIMEOUT_EXPIRED := new SyncStatus($911B);
private static _CONDITION_SATISFIED := new SyncStatus($911C);
private static _WAIT_FAILED := new SyncStatus($911D);
public static property ALREADY_SIGNALED: SyncStatus read _ALREADY_SIGNALED;
public static property TIMEOUT_EXPIRED: SyncStatus read _TIMEOUT_EXPIRED;
public static property CONDITION_SATISFIED: SyncStatus read _CONDITION_SATISFIED;
public static property WAIT_FAILED: SyncStatus read _WAIT_FAILED;
public function ToString: string; override;
begin
if self.val = UInt32($911A) then Result := 'ALREADY_SIGNALED' else
if self.val = UInt32($911B) then Result := 'TIMEOUT_EXPIRED' else
if self.val = UInt32($911C) then Result := 'CONDITION_SATISFIED' else
if self.val = UInt32($911D) then Result := 'WAIT_FAILED' else
Result := self.val.ToString;
end;
end;
TexCoordPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SHORT := new TexCoordPointerType($1402);
private static _INT := new TexCoordPointerType($1404);
private static _FLOAT := new TexCoordPointerType($1406);
private static _DOUBLE := new TexCoordPointerType($140A);
public static property SHORT: TexCoordPointerType read _SHORT;
public static property INT: TexCoordPointerType read _INT;
public static property FLOAT: TexCoordPointerType read _FLOAT;
public static property DOUBLE: TexCoordPointerType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
TextureCoordName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _S := new TextureCoordName($2000);
private static _T := new TextureCoordName($2001);
private static _R := new TextureCoordName($2002);
private static _Q := new TextureCoordName($2003);
public static property S: TextureCoordName read _S;
public static property T: TextureCoordName read _T;
public static property R: TextureCoordName read _R;
public static property Q: TextureCoordName read _Q;
public function ToString: string; override;
begin
if self.val = UInt32($2000) then Result := 'S' else
if self.val = UInt32($2001) then Result := 'T' else
if self.val = UInt32($2002) then Result := 'R' else
if self.val = UInt32($2003) then Result := 'Q' else
Result := self.val.ToString;
end;
end;
TextureEnvParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_ENV_MODE := new TextureEnvParameter($2200);
private static _TEXTURE_ENV_COLOR := new TextureEnvParameter($2201);
public static property TEXTURE_ENV_MODE: TextureEnvParameter read _TEXTURE_ENV_MODE;
public static property TEXTURE_ENV_COLOR: TextureEnvParameter read _TEXTURE_ENV_COLOR;
public function ToString: string; override;
begin
if self.val = UInt32($2200) then Result := 'TEXTURE_ENV_MODE' else
if self.val = UInt32($2201) then Result := 'TEXTURE_ENV_COLOR' else
Result := self.val.ToString;
end;
end;
TextureEnvTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_ENV := new TextureEnvTarget($2300);
public static property TEXTURE_ENV: TextureEnvTarget read _TEXTURE_ENV;
public function ToString: string; override;
begin
if self.val = UInt32($2300) then Result := 'TEXTURE_ENV' else
Result := self.val.ToString;
end;
end;
TextureGenParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_GEN_MODE := new TextureGenParameter($2500);
private static _OBJECT_PLANE := new TextureGenParameter($2501);
private static _EYE_PLANE := new TextureGenParameter($2502);
private static _EYE_POINT_SGIS := new TextureGenParameter($81F4);
private static _OBJECT_POINT_SGIS := new TextureGenParameter($81F5);
private static _EYE_LINE_SGIS := new TextureGenParameter($81F6);
private static _OBJECT_LINE_SGIS := new TextureGenParameter($81F7);
public static property TEXTURE_GEN_MODE: TextureGenParameter read _TEXTURE_GEN_MODE;
public static property OBJECT_PLANE: TextureGenParameter read _OBJECT_PLANE;
public static property EYE_PLANE: TextureGenParameter read _EYE_PLANE;
public static property EYE_POINT_SGIS: TextureGenParameter read _EYE_POINT_SGIS;
public static property OBJECT_POINT_SGIS: TextureGenParameter read _OBJECT_POINT_SGIS;
public static property EYE_LINE_SGIS: TextureGenParameter read _EYE_LINE_SGIS;
public static property OBJECT_LINE_SGIS: TextureGenParameter read _OBJECT_LINE_SGIS;
public function ToString: string; override;
begin
if self.val = UInt32($2500) then Result := 'TEXTURE_GEN_MODE' else
if self.val = UInt32($2501) then Result := 'OBJECT_PLANE' else
if self.val = UInt32($2502) then Result := 'EYE_PLANE' else
if self.val = UInt32($81F4) then Result := 'EYE_POINT_SGIS' else
if self.val = UInt32($81F5) then Result := 'OBJECT_POINT_SGIS' else
if self.val = UInt32($81F6) then Result := 'EYE_LINE_SGIS' else
if self.val = UInt32($81F7) then Result := 'OBJECT_LINE_SGIS' else
Result := self.val.ToString;
end;
end;
TextureLayout = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT := new TextureLayout($9530);
private static _LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT := new TextureLayout($9531);
private static _LAYOUT_GENERAL_EXT := new TextureLayout($958D);
private static _LAYOUT_COLOR_ATTACHMENT_EXT := new TextureLayout($958E);
private static _LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT := new TextureLayout($958F);
private static _LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT := new TextureLayout($9590);
private static _LAYOUT_SHADER_READ_ONLY_EXT := new TextureLayout($9591);
private static _LAYOUT_TRANSFER_SRC_EXT := new TextureLayout($9592);
private static _LAYOUT_TRANSFER_DST_EXT := new TextureLayout($9593);
public static property LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT: TextureLayout read _LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT;
public static property LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT: TextureLayout read _LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT;
public static property LAYOUT_GENERAL_EXT: TextureLayout read _LAYOUT_GENERAL_EXT;
public static property LAYOUT_COLOR_ATTACHMENT_EXT: TextureLayout read _LAYOUT_COLOR_ATTACHMENT_EXT;
public static property LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT: TextureLayout read _LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT;
public static property LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT: TextureLayout read _LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT;
public static property LAYOUT_SHADER_READ_ONLY_EXT: TextureLayout read _LAYOUT_SHADER_READ_ONLY_EXT;
public static property LAYOUT_TRANSFER_SRC_EXT: TextureLayout read _LAYOUT_TRANSFER_SRC_EXT;
public static property LAYOUT_TRANSFER_DST_EXT: TextureLayout read _LAYOUT_TRANSFER_DST_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($9530) then Result := 'LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT' else
if self.val = UInt32($9531) then Result := 'LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT' else
if self.val = UInt32($958D) then Result := 'LAYOUT_GENERAL_EXT' else
if self.val = UInt32($958E) then Result := 'LAYOUT_COLOR_ATTACHMENT_EXT' else
if self.val = UInt32($958F) then Result := 'LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT' else
if self.val = UInt32($9590) then Result := 'LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT' else
if self.val = UInt32($9591) then Result := 'LAYOUT_SHADER_READ_ONLY_EXT' else
if self.val = UInt32($9592) then Result := 'LAYOUT_TRANSFER_SRC_EXT' else
if self.val = UInt32($9593) then Result := 'LAYOUT_TRANSFER_DST_EXT' else
Result := self.val.ToString;
end;
end;
TextureParameterName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_WIDTH := new TextureParameterName($1000);
private static _TEXTURE_HEIGHT := new TextureParameterName($1001);
private static _TEXTURE_COMPONENTS := new TextureParameterName($1003);
private static _TEXTURE_INTERNAL_FORMAT := new TextureParameterName($1003);
private static _TEXTURE_BORDER_COLOR := new TextureParameterName($1004);
private static _TEXTURE_BORDER_COLOR_NV := new TextureParameterName($1004);
private static _TEXTURE_BORDER := new TextureParameterName($1005);
private static _TEXTURE_MAG_FILTER := new TextureParameterName($2800);
private static _TEXTURE_MIN_FILTER := new TextureParameterName($2801);
private static _TEXTURE_WRAP_S := new TextureParameterName($2802);
private static _TEXTURE_WRAP_T := new TextureParameterName($2803);
private static _TEXTURE_RED_SIZE := new TextureParameterName($805C);
private static _TEXTURE_GREEN_SIZE := new TextureParameterName($805D);
private static _TEXTURE_BLUE_SIZE := new TextureParameterName($805E);
private static _TEXTURE_ALPHA_SIZE := new TextureParameterName($805F);
private static _TEXTURE_LUMINANCE_SIZE := new TextureParameterName($8060);
private static _TEXTURE_INTENSITY_SIZE := new TextureParameterName($8061);
private static _TEXTURE_PRIORITY := new TextureParameterName($8066);
private static _TEXTURE_PRIORITY_EXT := new TextureParameterName($8066);
private static _TEXTURE_RESIDENT := new TextureParameterName($8067);
private static _TEXTURE_DEPTH_EXT := new TextureParameterName($8071);
private static _TEXTURE_WRAP_R := new TextureParameterName($8072);
private static _TEXTURE_WRAP_R_EXT := new TextureParameterName($8072);
private static _TEXTURE_WRAP_R_OES := new TextureParameterName($8072);
private static _DETAIL_TEXTURE_LEVEL_SGIS := new TextureParameterName($809A);
private static _DETAIL_TEXTURE_MODE_SGIS := new TextureParameterName($809B);
private static _DETAIL_TEXTURE_FUNC_POINTS_SGIS := new TextureParameterName($809C);
private static _SHARPEN_TEXTURE_FUNC_POINTS_SGIS := new TextureParameterName($80B0);
private static _SHADOW_AMBIENT_SGIX := new TextureParameterName($80BF);
private static _DUAL_TEXTURE_SELECT_SGIS := new TextureParameterName($8124);
private static _QUAD_TEXTURE_SELECT_SGIS := new TextureParameterName($8125);
private static _TEXTURE_4DSIZE_SGIS := new TextureParameterName($8136);
private static _TEXTURE_WRAP_Q_SGIS := new TextureParameterName($8137);
private static _TEXTURE_MIN_LOD := new TextureParameterName($813A);
private static _TEXTURE_MIN_LOD_SGIS := new TextureParameterName($813A);
private static _TEXTURE_MAX_LOD := new TextureParameterName($813B);
private static _TEXTURE_MAX_LOD_SGIS := new TextureParameterName($813B);
private static _TEXTURE_BASE_LEVEL := new TextureParameterName($813C);
private static _TEXTURE_BASE_LEVEL_SGIS := new TextureParameterName($813C);
private static _TEXTURE_MAX_LEVEL := new TextureParameterName($813D);
private static _TEXTURE_MAX_LEVEL_SGIS := new TextureParameterName($813D);
private static _TEXTURE_FILTER4_SIZE_SGIS := new TextureParameterName($8147);
private static _TEXTURE_CLIPMAP_CENTER_SGIX := new TextureParameterName($8171);
private static _TEXTURE_CLIPMAP_FRAME_SGIX := new TextureParameterName($8172);
private static _TEXTURE_CLIPMAP_OFFSET_SGIX := new TextureParameterName($8173);
private static _TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX := new TextureParameterName($8174);
private static _TEXTURE_CLIPMAP_LOD_OFFSET_SGIX := new TextureParameterName($8175);
private static _TEXTURE_CLIPMAP_DEPTH_SGIX := new TextureParameterName($8176);
private static _POST_TEXTURE_FILTER_BIAS_SGIX := new TextureParameterName($8179);
private static _POST_TEXTURE_FILTER_SCALE_SGIX := new TextureParameterName($817A);
private static _TEXTURE_LOD_BIAS_S_SGIX := new TextureParameterName($818E);
private static _TEXTURE_LOD_BIAS_T_SGIX := new TextureParameterName($818F);
private static _TEXTURE_LOD_BIAS_R_SGIX := new TextureParameterName($8190);
private static _GENERATE_MIPMAP := new TextureParameterName($8191);
private static _GENERATE_MIPMAP_SGIS := new TextureParameterName($8191);
private static _TEXTURE_COMPARE_SGIX := new TextureParameterName($819A);
private static _TEXTURE_COMPARE_OPERATOR_SGIX := new TextureParameterName($819B);
private static _TEXTURE_LEQUAL_R_SGIX := new TextureParameterName($819C);
private static _TEXTURE_GEQUAL_R_SGIX := new TextureParameterName($819D);
private static _TEXTURE_MAX_CLAMP_S_SGIX := new TextureParameterName($8369);
private static _TEXTURE_MAX_CLAMP_T_SGIX := new TextureParameterName($836A);
private static _TEXTURE_MAX_CLAMP_R_SGIX := new TextureParameterName($836B);
private static _TEXTURE_LOD_BIAS := new TextureParameterName($8501);
private static _TEXTURE_COMPARE_MODE := new TextureParameterName($884C);
private static _TEXTURE_COMPARE_FUNC := new TextureParameterName($884D);
private static _TEXTURE_SWIZZLE_R := new TextureParameterName($8E42);
private static _TEXTURE_SWIZZLE_G := new TextureParameterName($8E43);
private static _TEXTURE_SWIZZLE_B := new TextureParameterName($8E44);
private static _TEXTURE_SWIZZLE_A := new TextureParameterName($8E45);
private static _TEXTURE_SWIZZLE_RGBA := new TextureParameterName($8E46);
private static _TEXTURE_UNNORMALIZED_COORDINATES_ARM := new TextureParameterName($8F6A);
private static _DEPTH_STENCIL_TEXTURE_MODE := new TextureParameterName($90EA);
private static _TEXTURE_TILING_EXT := new TextureParameterName($9580);
public static property TEXTURE_WIDTH: TextureParameterName read _TEXTURE_WIDTH;
public static property TEXTURE_HEIGHT: TextureParameterName read _TEXTURE_HEIGHT;
public static property TEXTURE_COMPONENTS: TextureParameterName read _TEXTURE_COMPONENTS;
public static property TEXTURE_INTERNAL_FORMAT: TextureParameterName read _TEXTURE_INTERNAL_FORMAT;
public static property TEXTURE_BORDER_COLOR: TextureParameterName read _TEXTURE_BORDER_COLOR;
public static property TEXTURE_BORDER_COLOR_NV: TextureParameterName read _TEXTURE_BORDER_COLOR_NV;
public static property TEXTURE_BORDER: TextureParameterName read _TEXTURE_BORDER;
public static property TEXTURE_MAG_FILTER: TextureParameterName read _TEXTURE_MAG_FILTER;
public static property TEXTURE_MIN_FILTER: TextureParameterName read _TEXTURE_MIN_FILTER;
public static property TEXTURE_WRAP_S: TextureParameterName read _TEXTURE_WRAP_S;
public static property TEXTURE_WRAP_T: TextureParameterName read _TEXTURE_WRAP_T;
public static property TEXTURE_RED_SIZE: TextureParameterName read _TEXTURE_RED_SIZE;
public static property TEXTURE_GREEN_SIZE: TextureParameterName read _TEXTURE_GREEN_SIZE;
public static property TEXTURE_BLUE_SIZE: TextureParameterName read _TEXTURE_BLUE_SIZE;
public static property TEXTURE_ALPHA_SIZE: TextureParameterName read _TEXTURE_ALPHA_SIZE;
public static property TEXTURE_LUMINANCE_SIZE: TextureParameterName read _TEXTURE_LUMINANCE_SIZE;
public static property TEXTURE_INTENSITY_SIZE: TextureParameterName read _TEXTURE_INTENSITY_SIZE;
public static property TEXTURE_PRIORITY: TextureParameterName read _TEXTURE_PRIORITY;
public static property TEXTURE_PRIORITY_EXT: TextureParameterName read _TEXTURE_PRIORITY_EXT;
public static property TEXTURE_RESIDENT: TextureParameterName read _TEXTURE_RESIDENT;
public static property TEXTURE_DEPTH_EXT: TextureParameterName read _TEXTURE_DEPTH_EXT;
public static property TEXTURE_WRAP_R: TextureParameterName read _TEXTURE_WRAP_R;
public static property TEXTURE_WRAP_R_EXT: TextureParameterName read _TEXTURE_WRAP_R_EXT;
public static property TEXTURE_WRAP_R_OES: TextureParameterName read _TEXTURE_WRAP_R_OES;
public static property DETAIL_TEXTURE_LEVEL_SGIS: TextureParameterName read _DETAIL_TEXTURE_LEVEL_SGIS;
public static property DETAIL_TEXTURE_MODE_SGIS: TextureParameterName read _DETAIL_TEXTURE_MODE_SGIS;
public static property DETAIL_TEXTURE_FUNC_POINTS_SGIS: TextureParameterName read _DETAIL_TEXTURE_FUNC_POINTS_SGIS;
public static property SHARPEN_TEXTURE_FUNC_POINTS_SGIS: TextureParameterName read _SHARPEN_TEXTURE_FUNC_POINTS_SGIS;
public static property SHADOW_AMBIENT_SGIX: TextureParameterName read _SHADOW_AMBIENT_SGIX;
public static property DUAL_TEXTURE_SELECT_SGIS: TextureParameterName read _DUAL_TEXTURE_SELECT_SGIS;
public static property QUAD_TEXTURE_SELECT_SGIS: TextureParameterName read _QUAD_TEXTURE_SELECT_SGIS;
public static property TEXTURE_4DSIZE_SGIS: TextureParameterName read _TEXTURE_4DSIZE_SGIS;
public static property TEXTURE_WRAP_Q_SGIS: TextureParameterName read _TEXTURE_WRAP_Q_SGIS;
public static property TEXTURE_MIN_LOD: TextureParameterName read _TEXTURE_MIN_LOD;
public static property TEXTURE_MIN_LOD_SGIS: TextureParameterName read _TEXTURE_MIN_LOD_SGIS;
public static property TEXTURE_MAX_LOD: TextureParameterName read _TEXTURE_MAX_LOD;
public static property TEXTURE_MAX_LOD_SGIS: TextureParameterName read _TEXTURE_MAX_LOD_SGIS;
public static property TEXTURE_BASE_LEVEL: TextureParameterName read _TEXTURE_BASE_LEVEL;
public static property TEXTURE_BASE_LEVEL_SGIS: TextureParameterName read _TEXTURE_BASE_LEVEL_SGIS;
public static property TEXTURE_MAX_LEVEL: TextureParameterName read _TEXTURE_MAX_LEVEL;
public static property TEXTURE_MAX_LEVEL_SGIS: TextureParameterName read _TEXTURE_MAX_LEVEL_SGIS;
public static property TEXTURE_FILTER4_SIZE_SGIS: TextureParameterName read _TEXTURE_FILTER4_SIZE_SGIS;
public static property TEXTURE_CLIPMAP_CENTER_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_CENTER_SGIX;
public static property TEXTURE_CLIPMAP_FRAME_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_FRAME_SGIX;
public static property TEXTURE_CLIPMAP_OFFSET_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_OFFSET_SGIX;
public static property TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX;
public static property TEXTURE_CLIPMAP_LOD_OFFSET_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_LOD_OFFSET_SGIX;
public static property TEXTURE_CLIPMAP_DEPTH_SGIX: TextureParameterName read _TEXTURE_CLIPMAP_DEPTH_SGIX;
public static property POST_TEXTURE_FILTER_BIAS_SGIX: TextureParameterName read _POST_TEXTURE_FILTER_BIAS_SGIX;
public static property POST_TEXTURE_FILTER_SCALE_SGIX: TextureParameterName read _POST_TEXTURE_FILTER_SCALE_SGIX;
public static property TEXTURE_LOD_BIAS_S_SGIX: TextureParameterName read _TEXTURE_LOD_BIAS_S_SGIX;
public static property TEXTURE_LOD_BIAS_T_SGIX: TextureParameterName read _TEXTURE_LOD_BIAS_T_SGIX;
public static property TEXTURE_LOD_BIAS_R_SGIX: TextureParameterName read _TEXTURE_LOD_BIAS_R_SGIX;
public static property GENERATE_MIPMAP: TextureParameterName read _GENERATE_MIPMAP;
public static property GENERATE_MIPMAP_SGIS: TextureParameterName read _GENERATE_MIPMAP_SGIS;
public static property TEXTURE_COMPARE_SGIX: TextureParameterName read _TEXTURE_COMPARE_SGIX;
public static property TEXTURE_COMPARE_OPERATOR_SGIX: TextureParameterName read _TEXTURE_COMPARE_OPERATOR_SGIX;
public static property TEXTURE_LEQUAL_R_SGIX: TextureParameterName read _TEXTURE_LEQUAL_R_SGIX;
public static property TEXTURE_GEQUAL_R_SGIX: TextureParameterName read _TEXTURE_GEQUAL_R_SGIX;
public static property TEXTURE_MAX_CLAMP_S_SGIX: TextureParameterName read _TEXTURE_MAX_CLAMP_S_SGIX;
public static property TEXTURE_MAX_CLAMP_T_SGIX: TextureParameterName read _TEXTURE_MAX_CLAMP_T_SGIX;
public static property TEXTURE_MAX_CLAMP_R_SGIX: TextureParameterName read _TEXTURE_MAX_CLAMP_R_SGIX;
public static property TEXTURE_LOD_BIAS: TextureParameterName read _TEXTURE_LOD_BIAS;
public static property TEXTURE_COMPARE_MODE: TextureParameterName read _TEXTURE_COMPARE_MODE;
public static property TEXTURE_COMPARE_FUNC: TextureParameterName read _TEXTURE_COMPARE_FUNC;
public static property TEXTURE_SWIZZLE_R: TextureParameterName read _TEXTURE_SWIZZLE_R;
public static property TEXTURE_SWIZZLE_G: TextureParameterName read _TEXTURE_SWIZZLE_G;
public static property TEXTURE_SWIZZLE_B: TextureParameterName read _TEXTURE_SWIZZLE_B;
public static property TEXTURE_SWIZZLE_A: TextureParameterName read _TEXTURE_SWIZZLE_A;
public static property TEXTURE_SWIZZLE_RGBA: TextureParameterName read _TEXTURE_SWIZZLE_RGBA;
public static property TEXTURE_UNNORMALIZED_COORDINATES_ARM: TextureParameterName read _TEXTURE_UNNORMALIZED_COORDINATES_ARM;
public static property DEPTH_STENCIL_TEXTURE_MODE: TextureParameterName read _DEPTH_STENCIL_TEXTURE_MODE;
public static property TEXTURE_TILING_EXT: TextureParameterName read _TEXTURE_TILING_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($1000) then Result := 'TEXTURE_WIDTH' else
if self.val = UInt32($1001) then Result := 'TEXTURE_HEIGHT' else
if self.val = UInt32($1003) then Result := 'TEXTURE_COMPONENTS' else
if self.val = UInt32($1003) then Result := 'TEXTURE_INTERNAL_FORMAT' else
if self.val = UInt32($1004) then Result := 'TEXTURE_BORDER_COLOR' else
if self.val = UInt32($1004) then Result := 'TEXTURE_BORDER_COLOR_NV' else
if self.val = UInt32($1005) then Result := 'TEXTURE_BORDER' else
if self.val = UInt32($2800) then Result := 'TEXTURE_MAG_FILTER' else
if self.val = UInt32($2801) then Result := 'TEXTURE_MIN_FILTER' else
if self.val = UInt32($2802) then Result := 'TEXTURE_WRAP_S' else
if self.val = UInt32($2803) then Result := 'TEXTURE_WRAP_T' else
if self.val = UInt32($805C) then Result := 'TEXTURE_RED_SIZE' else
if self.val = UInt32($805D) then Result := 'TEXTURE_GREEN_SIZE' else
if self.val = UInt32($805E) then Result := 'TEXTURE_BLUE_SIZE' else
if self.val = UInt32($805F) then Result := 'TEXTURE_ALPHA_SIZE' else
if self.val = UInt32($8060) then Result := 'TEXTURE_LUMINANCE_SIZE' else
if self.val = UInt32($8061) then Result := 'TEXTURE_INTENSITY_SIZE' else
if self.val = UInt32($8066) then Result := 'TEXTURE_PRIORITY' else
if self.val = UInt32($8066) then Result := 'TEXTURE_PRIORITY_EXT' else
if self.val = UInt32($8067) then Result := 'TEXTURE_RESIDENT' else
if self.val = UInt32($8071) then Result := 'TEXTURE_DEPTH_EXT' else
if self.val = UInt32($8072) then Result := 'TEXTURE_WRAP_R' else
if self.val = UInt32($8072) then Result := 'TEXTURE_WRAP_R_EXT' else
if self.val = UInt32($8072) then Result := 'TEXTURE_WRAP_R_OES' else
if self.val = UInt32($809A) then Result := 'DETAIL_TEXTURE_LEVEL_SGIS' else
if self.val = UInt32($809B) then Result := 'DETAIL_TEXTURE_MODE_SGIS' else
if self.val = UInt32($809C) then Result := 'DETAIL_TEXTURE_FUNC_POINTS_SGIS' else
if self.val = UInt32($80B0) then Result := 'SHARPEN_TEXTURE_FUNC_POINTS_SGIS' else
if self.val = UInt32($80BF) then Result := 'SHADOW_AMBIENT_SGIX' else
if self.val = UInt32($8124) then Result := 'DUAL_TEXTURE_SELECT_SGIS' else
if self.val = UInt32($8125) then Result := 'QUAD_TEXTURE_SELECT_SGIS' else
if self.val = UInt32($8136) then Result := 'TEXTURE_4DSIZE_SGIS' else
if self.val = UInt32($8137) then Result := 'TEXTURE_WRAP_Q_SGIS' else
if self.val = UInt32($813A) then Result := 'TEXTURE_MIN_LOD' else
if self.val = UInt32($813A) then Result := 'TEXTURE_MIN_LOD_SGIS' else
if self.val = UInt32($813B) then Result := 'TEXTURE_MAX_LOD' else
if self.val = UInt32($813B) then Result := 'TEXTURE_MAX_LOD_SGIS' else
if self.val = UInt32($813C) then Result := 'TEXTURE_BASE_LEVEL' else
if self.val = UInt32($813C) then Result := 'TEXTURE_BASE_LEVEL_SGIS' else
if self.val = UInt32($813D) then Result := 'TEXTURE_MAX_LEVEL' else
if self.val = UInt32($813D) then Result := 'TEXTURE_MAX_LEVEL_SGIS' else
if self.val = UInt32($8147) then Result := 'TEXTURE_FILTER4_SIZE_SGIS' else
if self.val = UInt32($8171) then Result := 'TEXTURE_CLIPMAP_CENTER_SGIX' else
if self.val = UInt32($8172) then Result := 'TEXTURE_CLIPMAP_FRAME_SGIX' else
if self.val = UInt32($8173) then Result := 'TEXTURE_CLIPMAP_OFFSET_SGIX' else
if self.val = UInt32($8174) then Result := 'TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX' else
if self.val = UInt32($8175) then Result := 'TEXTURE_CLIPMAP_LOD_OFFSET_SGIX' else
if self.val = UInt32($8176) then Result := 'TEXTURE_CLIPMAP_DEPTH_SGIX' else
if self.val = UInt32($8179) then Result := 'POST_TEXTURE_FILTER_BIAS_SGIX' else
if self.val = UInt32($817A) then Result := 'POST_TEXTURE_FILTER_SCALE_SGIX' else
if self.val = UInt32($818E) then Result := 'TEXTURE_LOD_BIAS_S_SGIX' else
if self.val = UInt32($818F) then Result := 'TEXTURE_LOD_BIAS_T_SGIX' else
if self.val = UInt32($8190) then Result := 'TEXTURE_LOD_BIAS_R_SGIX' else
if self.val = UInt32($8191) then Result := 'GENERATE_MIPMAP' else
if self.val = UInt32($8191) then Result := 'GENERATE_MIPMAP_SGIS' else
if self.val = UInt32($819A) then Result := 'TEXTURE_COMPARE_SGIX' else
if self.val = UInt32($819B) then Result := 'TEXTURE_COMPARE_OPERATOR_SGIX' else
if self.val = UInt32($819C) then Result := 'TEXTURE_LEQUAL_R_SGIX' else
if self.val = UInt32($819D) then Result := 'TEXTURE_GEQUAL_R_SGIX' else
if self.val = UInt32($8369) then Result := 'TEXTURE_MAX_CLAMP_S_SGIX' else
if self.val = UInt32($836A) then Result := 'TEXTURE_MAX_CLAMP_T_SGIX' else
if self.val = UInt32($836B) then Result := 'TEXTURE_MAX_CLAMP_R_SGIX' else
if self.val = UInt32($8501) then Result := 'TEXTURE_LOD_BIAS' else
if self.val = UInt32($884C) then Result := 'TEXTURE_COMPARE_MODE' else
if self.val = UInt32($884D) then Result := 'TEXTURE_COMPARE_FUNC' else
if self.val = UInt32($8E42) then Result := 'TEXTURE_SWIZZLE_R' else
if self.val = UInt32($8E43) then Result := 'TEXTURE_SWIZZLE_G' else
if self.val = UInt32($8E44) then Result := 'TEXTURE_SWIZZLE_B' else
if self.val = UInt32($8E45) then Result := 'TEXTURE_SWIZZLE_A' else
if self.val = UInt32($8E46) then Result := 'TEXTURE_SWIZZLE_RGBA' else
if self.val = UInt32($8F6A) then Result := 'TEXTURE_UNNORMALIZED_COORDINATES_ARM' else
if self.val = UInt32($90EA) then Result := 'DEPTH_STENCIL_TEXTURE_MODE' else
if self.val = UInt32($9580) then Result := 'TEXTURE_TILING_EXT' else
Result := self.val.ToString;
end;
end;
TextureTarget = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_1D := new TextureTarget($0DE0);
private static _TEXTURE_2D := new TextureTarget($0DE1);
private static _PROXY_TEXTURE_1D := new TextureTarget($8063);
private static _PROXY_TEXTURE_1D_EXT := new TextureTarget($8063);
private static _PROXY_TEXTURE_2D := new TextureTarget($8064);
private static _PROXY_TEXTURE_2D_EXT := new TextureTarget($8064);
private static _TEXTURE_3D := new TextureTarget($806F);
private static _TEXTURE_3D_EXT := new TextureTarget($806F);
private static _TEXTURE_3D_OES := new TextureTarget($806F);
private static _PROXY_TEXTURE_3D := new TextureTarget($8070);
private static _PROXY_TEXTURE_3D_EXT := new TextureTarget($8070);
private static _DETAIL_TEXTURE_2D_SGIS := new TextureTarget($8095);
private static _TEXTURE_4D_SGIS := new TextureTarget($8134);
private static _PROXY_TEXTURE_4D_SGIS := new TextureTarget($8135);
private static _TEXTURE_RECTANGLE := new TextureTarget($84F5);
private static _PROXY_TEXTURE_RECTANGLE := new TextureTarget($84F7);
private static _PROXY_TEXTURE_RECTANGLE_ARB := new TextureTarget($84F7);
private static _PROXY_TEXTURE_RECTANGLE_NV := new TextureTarget($84F7);
private static _TEXTURE_CUBE_MAP := new TextureTarget($8513);
private static _TEXTURE_CUBE_MAP_POSITIVE_X := new TextureTarget($8515);
private static _TEXTURE_CUBE_MAP_NEGATIVE_X := new TextureTarget($8516);
private static _TEXTURE_CUBE_MAP_POSITIVE_Y := new TextureTarget($8517);
private static _TEXTURE_CUBE_MAP_NEGATIVE_Y := new TextureTarget($8518);
private static _TEXTURE_CUBE_MAP_POSITIVE_Z := new TextureTarget($8519);
private static _TEXTURE_CUBE_MAP_NEGATIVE_Z := new TextureTarget($851A);
private static _PROXY_TEXTURE_CUBE_MAP := new TextureTarget($851B);
private static _PROXY_TEXTURE_CUBE_MAP_ARB := new TextureTarget($851B);
private static _PROXY_TEXTURE_CUBE_MAP_EXT := new TextureTarget($851B);
private static _TEXTURE_1D_ARRAY := new TextureTarget($8C18);
private static _PROXY_TEXTURE_1D_ARRAY := new TextureTarget($8C19);
private static _PROXY_TEXTURE_1D_ARRAY_EXT := new TextureTarget($8C19);
private static _TEXTURE_2D_ARRAY := new TextureTarget($8C1A);
private static _PROXY_TEXTURE_2D_ARRAY := new TextureTarget($8C1B);
private static _PROXY_TEXTURE_2D_ARRAY_EXT := new TextureTarget($8C1B);
private static _TEXTURE_CUBE_MAP_ARRAY := new TextureTarget($9009);
private static _TEXTURE_CUBE_MAP_ARRAY_ARB := new TextureTarget($9009);
private static _TEXTURE_CUBE_MAP_ARRAY_EXT := new TextureTarget($9009);
private static _TEXTURE_CUBE_MAP_ARRAY_OES := new TextureTarget($9009);
private static _PROXY_TEXTURE_CUBE_MAP_ARRAY := new TextureTarget($900B);
private static _PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB := new TextureTarget($900B);
private static _TEXTURE_2D_MULTISAMPLE := new TextureTarget($9100);
private static _PROXY_TEXTURE_2D_MULTISAMPLE := new TextureTarget($9101);
private static _TEXTURE_2D_MULTISAMPLE_ARRAY := new TextureTarget($9102);
private static _PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY := new TextureTarget($9103);
public static property TEXTURE_1D: TextureTarget read _TEXTURE_1D;
public static property TEXTURE_2D: TextureTarget read _TEXTURE_2D;
public static property PROXY_TEXTURE_1D: TextureTarget read _PROXY_TEXTURE_1D;
public static property PROXY_TEXTURE_1D_EXT: TextureTarget read _PROXY_TEXTURE_1D_EXT;
public static property PROXY_TEXTURE_2D: TextureTarget read _PROXY_TEXTURE_2D;
public static property PROXY_TEXTURE_2D_EXT: TextureTarget read _PROXY_TEXTURE_2D_EXT;
public static property TEXTURE_3D: TextureTarget read _TEXTURE_3D;
public static property TEXTURE_3D_EXT: TextureTarget read _TEXTURE_3D_EXT;
public static property TEXTURE_3D_OES: TextureTarget read _TEXTURE_3D_OES;
public static property PROXY_TEXTURE_3D: TextureTarget read _PROXY_TEXTURE_3D;
public static property PROXY_TEXTURE_3D_EXT: TextureTarget read _PROXY_TEXTURE_3D_EXT;
public static property DETAIL_TEXTURE_2D_SGIS: TextureTarget read _DETAIL_TEXTURE_2D_SGIS;
public static property TEXTURE_4D_SGIS: TextureTarget read _TEXTURE_4D_SGIS;
public static property PROXY_TEXTURE_4D_SGIS: TextureTarget read _PROXY_TEXTURE_4D_SGIS;
public static property TEXTURE_RECTANGLE: TextureTarget read _TEXTURE_RECTANGLE;
public static property PROXY_TEXTURE_RECTANGLE: TextureTarget read _PROXY_TEXTURE_RECTANGLE;
public static property PROXY_TEXTURE_RECTANGLE_ARB: TextureTarget read _PROXY_TEXTURE_RECTANGLE_ARB;
public static property PROXY_TEXTURE_RECTANGLE_NV: TextureTarget read _PROXY_TEXTURE_RECTANGLE_NV;
public static property TEXTURE_CUBE_MAP: TextureTarget read _TEXTURE_CUBE_MAP;
public static property TEXTURE_CUBE_MAP_POSITIVE_X: TextureTarget read _TEXTURE_CUBE_MAP_POSITIVE_X;
public static property TEXTURE_CUBE_MAP_NEGATIVE_X: TextureTarget read _TEXTURE_CUBE_MAP_NEGATIVE_X;
public static property TEXTURE_CUBE_MAP_POSITIVE_Y: TextureTarget read _TEXTURE_CUBE_MAP_POSITIVE_Y;
public static property TEXTURE_CUBE_MAP_NEGATIVE_Y: TextureTarget read _TEXTURE_CUBE_MAP_NEGATIVE_Y;
public static property TEXTURE_CUBE_MAP_POSITIVE_Z: TextureTarget read _TEXTURE_CUBE_MAP_POSITIVE_Z;
public static property TEXTURE_CUBE_MAP_NEGATIVE_Z: TextureTarget read _TEXTURE_CUBE_MAP_NEGATIVE_Z;
public static property PROXY_TEXTURE_CUBE_MAP: TextureTarget read _PROXY_TEXTURE_CUBE_MAP;
public static property PROXY_TEXTURE_CUBE_MAP_ARB: TextureTarget read _PROXY_TEXTURE_CUBE_MAP_ARB;
public static property PROXY_TEXTURE_CUBE_MAP_EXT: TextureTarget read _PROXY_TEXTURE_CUBE_MAP_EXT;
public static property TEXTURE_1D_ARRAY: TextureTarget read _TEXTURE_1D_ARRAY;
public static property PROXY_TEXTURE_1D_ARRAY: TextureTarget read _PROXY_TEXTURE_1D_ARRAY;
public static property PROXY_TEXTURE_1D_ARRAY_EXT: TextureTarget read _PROXY_TEXTURE_1D_ARRAY_EXT;
public static property TEXTURE_2D_ARRAY: TextureTarget read _TEXTURE_2D_ARRAY;
public static property PROXY_TEXTURE_2D_ARRAY: TextureTarget read _PROXY_TEXTURE_2D_ARRAY;
public static property PROXY_TEXTURE_2D_ARRAY_EXT: TextureTarget read _PROXY_TEXTURE_2D_ARRAY_EXT;
public static property TEXTURE_CUBE_MAP_ARRAY: TextureTarget read _TEXTURE_CUBE_MAP_ARRAY;
public static property TEXTURE_CUBE_MAP_ARRAY_ARB: TextureTarget read _TEXTURE_CUBE_MAP_ARRAY_ARB;
public static property TEXTURE_CUBE_MAP_ARRAY_EXT: TextureTarget read _TEXTURE_CUBE_MAP_ARRAY_EXT;
public static property TEXTURE_CUBE_MAP_ARRAY_OES: TextureTarget read _TEXTURE_CUBE_MAP_ARRAY_OES;
public static property PROXY_TEXTURE_CUBE_MAP_ARRAY: TextureTarget read _PROXY_TEXTURE_CUBE_MAP_ARRAY;
public static property PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB: TextureTarget read _PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB;
public static property TEXTURE_2D_MULTISAMPLE: TextureTarget read _TEXTURE_2D_MULTISAMPLE;
public static property PROXY_TEXTURE_2D_MULTISAMPLE: TextureTarget read _PROXY_TEXTURE_2D_MULTISAMPLE;
public static property TEXTURE_2D_MULTISAMPLE_ARRAY: TextureTarget read _TEXTURE_2D_MULTISAMPLE_ARRAY;
public static property PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY: TextureTarget read _PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY;
public function ToString: string; override;
begin
if self.val = UInt32($0DE0) then Result := 'TEXTURE_1D' else
if self.val = UInt32($0DE1) then Result := 'TEXTURE_2D' else
if self.val = UInt32($8063) then Result := 'PROXY_TEXTURE_1D' else
if self.val = UInt32($8063) then Result := 'PROXY_TEXTURE_1D_EXT' else
if self.val = UInt32($8064) then Result := 'PROXY_TEXTURE_2D' else
if self.val = UInt32($8064) then Result := 'PROXY_TEXTURE_2D_EXT' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D_EXT' else
if self.val = UInt32($806F) then Result := 'TEXTURE_3D_OES' else
if self.val = UInt32($8070) then Result := 'PROXY_TEXTURE_3D' else
if self.val = UInt32($8070) then Result := 'PROXY_TEXTURE_3D_EXT' else
if self.val = UInt32($8095) then Result := 'DETAIL_TEXTURE_2D_SGIS' else
if self.val = UInt32($8134) then Result := 'TEXTURE_4D_SGIS' else
if self.val = UInt32($8135) then Result := 'PROXY_TEXTURE_4D_SGIS' else
if self.val = UInt32($84F5) then Result := 'TEXTURE_RECTANGLE' else
if self.val = UInt32($84F7) then Result := 'PROXY_TEXTURE_RECTANGLE' else
if self.val = UInt32($84F7) then Result := 'PROXY_TEXTURE_RECTANGLE_ARB' else
if self.val = UInt32($84F7) then Result := 'PROXY_TEXTURE_RECTANGLE_NV' else
if self.val = UInt32($8513) then Result := 'TEXTURE_CUBE_MAP' else
if self.val = UInt32($8515) then Result := 'TEXTURE_CUBE_MAP_POSITIVE_X' else
if self.val = UInt32($8516) then Result := 'TEXTURE_CUBE_MAP_NEGATIVE_X' else
if self.val = UInt32($8517) then Result := 'TEXTURE_CUBE_MAP_POSITIVE_Y' else
if self.val = UInt32($8518) then Result := 'TEXTURE_CUBE_MAP_NEGATIVE_Y' else
if self.val = UInt32($8519) then Result := 'TEXTURE_CUBE_MAP_POSITIVE_Z' else
if self.val = UInt32($851A) then Result := 'TEXTURE_CUBE_MAP_NEGATIVE_Z' else
if self.val = UInt32($851B) then Result := 'PROXY_TEXTURE_CUBE_MAP' else
if self.val = UInt32($851B) then Result := 'PROXY_TEXTURE_CUBE_MAP_ARB' else
if self.val = UInt32($851B) then Result := 'PROXY_TEXTURE_CUBE_MAP_EXT' else
if self.val = UInt32($8C18) then Result := 'TEXTURE_1D_ARRAY' else
if self.val = UInt32($8C19) then Result := 'PROXY_TEXTURE_1D_ARRAY' else
if self.val = UInt32($8C19) then Result := 'PROXY_TEXTURE_1D_ARRAY_EXT' else
if self.val = UInt32($8C1A) then Result := 'TEXTURE_2D_ARRAY' else
if self.val = UInt32($8C1B) then Result := 'PROXY_TEXTURE_2D_ARRAY' else
if self.val = UInt32($8C1B) then Result := 'PROXY_TEXTURE_2D_ARRAY_EXT' else
if self.val = UInt32($9009) then Result := 'TEXTURE_CUBE_MAP_ARRAY' else
if self.val = UInt32($9009) then Result := 'TEXTURE_CUBE_MAP_ARRAY_ARB' else
if self.val = UInt32($9009) then Result := 'TEXTURE_CUBE_MAP_ARRAY_EXT' else
if self.val = UInt32($9009) then Result := 'TEXTURE_CUBE_MAP_ARRAY_OES' else
if self.val = UInt32($900B) then Result := 'PROXY_TEXTURE_CUBE_MAP_ARRAY' else
if self.val = UInt32($900B) then Result := 'PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB' else
if self.val = UInt32($9100) then Result := 'TEXTURE_2D_MULTISAMPLE' else
if self.val = UInt32($9101) then Result := 'PROXY_TEXTURE_2D_MULTISAMPLE' else
if self.val = UInt32($9102) then Result := 'TEXTURE_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($9103) then Result := 'PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY' else
Result := self.val.ToString;
end;
end;
TextureUnit = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE0 := new TextureUnit($84C0);
private static _TEXTURE1 := new TextureUnit($84C1);
private static _TEXTURE2 := new TextureUnit($84C2);
private static _TEXTURE3 := new TextureUnit($84C3);
private static _TEXTURE4 := new TextureUnit($84C4);
private static _TEXTURE5 := new TextureUnit($84C5);
private static _TEXTURE6 := new TextureUnit($84C6);
private static _TEXTURE7 := new TextureUnit($84C7);
private static _TEXTURE8 := new TextureUnit($84C8);
private static _TEXTURE9 := new TextureUnit($84C9);
private static _TEXTURE10 := new TextureUnit($84CA);
private static _TEXTURE11 := new TextureUnit($84CB);
private static _TEXTURE12 := new TextureUnit($84CC);
private static _TEXTURE13 := new TextureUnit($84CD);
private static _TEXTURE14 := new TextureUnit($84CE);
private static _TEXTURE15 := new TextureUnit($84CF);
private static _TEXTURE16 := new TextureUnit($84D0);
private static _TEXTURE17 := new TextureUnit($84D1);
private static _TEXTURE18 := new TextureUnit($84D2);
private static _TEXTURE19 := new TextureUnit($84D3);
private static _TEXTURE20 := new TextureUnit($84D4);
private static _TEXTURE21 := new TextureUnit($84D5);
private static _TEXTURE22 := new TextureUnit($84D6);
private static _TEXTURE23 := new TextureUnit($84D7);
private static _TEXTURE24 := new TextureUnit($84D8);
private static _TEXTURE25 := new TextureUnit($84D9);
private static _TEXTURE26 := new TextureUnit($84DA);
private static _TEXTURE27 := new TextureUnit($84DB);
private static _TEXTURE28 := new TextureUnit($84DC);
private static _TEXTURE29 := new TextureUnit($84DD);
private static _TEXTURE30 := new TextureUnit($84DE);
private static _TEXTURE31 := new TextureUnit($84DF);
public static property TEXTURE0: TextureUnit read _TEXTURE0;
public static property TEXTURE1: TextureUnit read _TEXTURE1;
public static property TEXTURE2: TextureUnit read _TEXTURE2;
public static property TEXTURE3: TextureUnit read _TEXTURE3;
public static property TEXTURE4: TextureUnit read _TEXTURE4;
public static property TEXTURE5: TextureUnit read _TEXTURE5;
public static property TEXTURE6: TextureUnit read _TEXTURE6;
public static property TEXTURE7: TextureUnit read _TEXTURE7;
public static property TEXTURE8: TextureUnit read _TEXTURE8;
public static property TEXTURE9: TextureUnit read _TEXTURE9;
public static property TEXTURE10: TextureUnit read _TEXTURE10;
public static property TEXTURE11: TextureUnit read _TEXTURE11;
public static property TEXTURE12: TextureUnit read _TEXTURE12;
public static property TEXTURE13: TextureUnit read _TEXTURE13;
public static property TEXTURE14: TextureUnit read _TEXTURE14;
public static property TEXTURE15: TextureUnit read _TEXTURE15;
public static property TEXTURE16: TextureUnit read _TEXTURE16;
public static property TEXTURE17: TextureUnit read _TEXTURE17;
public static property TEXTURE18: TextureUnit read _TEXTURE18;
public static property TEXTURE19: TextureUnit read _TEXTURE19;
public static property TEXTURE20: TextureUnit read _TEXTURE20;
public static property TEXTURE21: TextureUnit read _TEXTURE21;
public static property TEXTURE22: TextureUnit read _TEXTURE22;
public static property TEXTURE23: TextureUnit read _TEXTURE23;
public static property TEXTURE24: TextureUnit read _TEXTURE24;
public static property TEXTURE25: TextureUnit read _TEXTURE25;
public static property TEXTURE26: TextureUnit read _TEXTURE26;
public static property TEXTURE27: TextureUnit read _TEXTURE27;
public static property TEXTURE28: TextureUnit read _TEXTURE28;
public static property TEXTURE29: TextureUnit read _TEXTURE29;
public static property TEXTURE30: TextureUnit read _TEXTURE30;
public static property TEXTURE31: TextureUnit read _TEXTURE31;
public function ToString: string; override;
begin
if self.val = UInt32($84C0) then Result := 'TEXTURE0' else
if self.val = UInt32($84C1) then Result := 'TEXTURE1' else
if self.val = UInt32($84C2) then Result := 'TEXTURE2' else
if self.val = UInt32($84C3) then Result := 'TEXTURE3' else
if self.val = UInt32($84C4) then Result := 'TEXTURE4' else
if self.val = UInt32($84C5) then Result := 'TEXTURE5' else
if self.val = UInt32($84C6) then Result := 'TEXTURE6' else
if self.val = UInt32($84C7) then Result := 'TEXTURE7' else
if self.val = UInt32($84C8) then Result := 'TEXTURE8' else
if self.val = UInt32($84C9) then Result := 'TEXTURE9' else
if self.val = UInt32($84CA) then Result := 'TEXTURE10' else
if self.val = UInt32($84CB) then Result := 'TEXTURE11' else
if self.val = UInt32($84CC) then Result := 'TEXTURE12' else
if self.val = UInt32($84CD) then Result := 'TEXTURE13' else
if self.val = UInt32($84CE) then Result := 'TEXTURE14' else
if self.val = UInt32($84CF) then Result := 'TEXTURE15' else
if self.val = UInt32($84D0) then Result := 'TEXTURE16' else
if self.val = UInt32($84D1) then Result := 'TEXTURE17' else
if self.val = UInt32($84D2) then Result := 'TEXTURE18' else
if self.val = UInt32($84D3) then Result := 'TEXTURE19' else
if self.val = UInt32($84D4) then Result := 'TEXTURE20' else
if self.val = UInt32($84D5) then Result := 'TEXTURE21' else
if self.val = UInt32($84D6) then Result := 'TEXTURE22' else
if self.val = UInt32($84D7) then Result := 'TEXTURE23' else
if self.val = UInt32($84D8) then Result := 'TEXTURE24' else
if self.val = UInt32($84D9) then Result := 'TEXTURE25' else
if self.val = UInt32($84DA) then Result := 'TEXTURE26' else
if self.val = UInt32($84DB) then Result := 'TEXTURE27' else
if self.val = UInt32($84DC) then Result := 'TEXTURE28' else
if self.val = UInt32($84DD) then Result := 'TEXTURE29' else
if self.val = UInt32($84DE) then Result := 'TEXTURE30' else
if self.val = UInt32($84DF) then Result := 'TEXTURE31' else
Result := self.val.ToString;
end;
end;
TransformFeedbackBufferMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INTERLEAVED_ATTRIBS := new TransformFeedbackBufferMode($8C8C);
private static _SEPARATE_ATTRIBS := new TransformFeedbackBufferMode($8C8D);
public static property INTERLEAVED_ATTRIBS: TransformFeedbackBufferMode read _INTERLEAVED_ATTRIBS;
public static property SEPARATE_ATTRIBS: TransformFeedbackBufferMode read _SEPARATE_ATTRIBS;
public function ToString: string; override;
begin
if self.val = UInt32($8C8C) then Result := 'INTERLEAVED_ATTRIBS' else
if self.val = UInt32($8C8D) then Result := 'SEPARATE_ATTRIBS' else
Result := self.val.ToString;
end;
end;
TransformFeedbackPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TRANSFORM_FEEDBACK_BUFFER_START := new TransformFeedbackPName($8C84);
private static _TRANSFORM_FEEDBACK_BUFFER_SIZE := new TransformFeedbackPName($8C85);
private static _TRANSFORM_FEEDBACK_BUFFER_BINDING := new TransformFeedbackPName($8C8F);
private static _TRANSFORM_FEEDBACK_PAUSED := new TransformFeedbackPName($8E23);
private static _TRANSFORM_FEEDBACK_ACTIVE := new TransformFeedbackPName($8E24);
public static property TRANSFORM_FEEDBACK_BUFFER_START: TransformFeedbackPName read _TRANSFORM_FEEDBACK_BUFFER_START;
public static property TRANSFORM_FEEDBACK_BUFFER_SIZE: TransformFeedbackPName read _TRANSFORM_FEEDBACK_BUFFER_SIZE;
public static property TRANSFORM_FEEDBACK_BUFFER_BINDING: TransformFeedbackPName read _TRANSFORM_FEEDBACK_BUFFER_BINDING;
public static property TRANSFORM_FEEDBACK_PAUSED: TransformFeedbackPName read _TRANSFORM_FEEDBACK_PAUSED;
public static property TRANSFORM_FEEDBACK_ACTIVE: TransformFeedbackPName read _TRANSFORM_FEEDBACK_ACTIVE;
public function ToString: string; override;
begin
if self.val = UInt32($8C84) then Result := 'TRANSFORM_FEEDBACK_BUFFER_START' else
if self.val = UInt32($8C85) then Result := 'TRANSFORM_FEEDBACK_BUFFER_SIZE' else
if self.val = UInt32($8C8F) then Result := 'TRANSFORM_FEEDBACK_BUFFER_BINDING' else
if self.val = UInt32($8E23) then Result := 'TRANSFORM_FEEDBACK_PAUSED' else
if self.val = UInt32($8E24) then Result := 'TRANSFORM_FEEDBACK_ACTIVE' else
Result := self.val.ToString;
end;
end;
UniformBlockPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER := new UniformBlockPName($84F0);
private static _UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER := new UniformBlockPName($84F1);
private static _UNIFORM_BLOCK_BINDING := new UniformBlockPName($8A3F);
private static _UNIFORM_BLOCK_DATA_SIZE := new UniformBlockPName($8A40);
private static _UNIFORM_BLOCK_NAME_LENGTH := new UniformBlockPName($8A41);
private static _UNIFORM_BLOCK_ACTIVE_UNIFORMS := new UniformBlockPName($8A42);
private static _UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES := new UniformBlockPName($8A43);
private static _UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER := new UniformBlockPName($8A44);
private static _UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER := new UniformBlockPName($8A45);
private static _UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER := new UniformBlockPName($8A46);
private static _UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER := new UniformBlockPName($90EC);
public static property UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER;
public static property UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER;
public static property UNIFORM_BLOCK_BINDING: UniformBlockPName read _UNIFORM_BLOCK_BINDING;
public static property UNIFORM_BLOCK_DATA_SIZE: UniformBlockPName read _UNIFORM_BLOCK_DATA_SIZE;
public static property UNIFORM_BLOCK_NAME_LENGTH: UniformBlockPName read _UNIFORM_BLOCK_NAME_LENGTH;
public static property UNIFORM_BLOCK_ACTIVE_UNIFORMS: UniformBlockPName read _UNIFORM_BLOCK_ACTIVE_UNIFORMS;
public static property UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: UniformBlockPName read _UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES;
public static property UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER;
public static property UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER;
public static property UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER;
public static property UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER: UniformBlockPName read _UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER;
public function ToString: string; override;
begin
if self.val = UInt32($84F0) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER' else
if self.val = UInt32($84F1) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER' else
if self.val = UInt32($8A3F) then Result := 'UNIFORM_BLOCK_BINDING' else
if self.val = UInt32($8A40) then Result := 'UNIFORM_BLOCK_DATA_SIZE' else
if self.val = UInt32($8A41) then Result := 'UNIFORM_BLOCK_NAME_LENGTH' else
if self.val = UInt32($8A42) then Result := 'UNIFORM_BLOCK_ACTIVE_UNIFORMS' else
if self.val = UInt32($8A43) then Result := 'UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES' else
if self.val = UInt32($8A44) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER' else
if self.val = UInt32($8A45) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER' else
if self.val = UInt32($8A46) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER' else
if self.val = UInt32($90EC) then Result := 'UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER' else
Result := self.val.ToString;
end;
end;
UniformPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNIFORM_TYPE := new UniformPName($8A37);
private static _UNIFORM_SIZE := new UniformPName($8A38);
private static _UNIFORM_NAME_LENGTH := new UniformPName($8A39);
private static _UNIFORM_BLOCK_INDEX := new UniformPName($8A3A);
private static _UNIFORM_OFFSET := new UniformPName($8A3B);
private static _UNIFORM_ARRAY_STRIDE := new UniformPName($8A3C);
private static _UNIFORM_MATRIX_STRIDE := new UniformPName($8A3D);
private static _UNIFORM_IS_ROW_MAJOR := new UniformPName($8A3E);
private static _UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX := new UniformPName($92DA);
public static property UNIFORM_TYPE: UniformPName read _UNIFORM_TYPE;
public static property UNIFORM_SIZE: UniformPName read _UNIFORM_SIZE;
public static property UNIFORM_NAME_LENGTH: UniformPName read _UNIFORM_NAME_LENGTH;
public static property UNIFORM_BLOCK_INDEX: UniformPName read _UNIFORM_BLOCK_INDEX;
public static property UNIFORM_OFFSET: UniformPName read _UNIFORM_OFFSET;
public static property UNIFORM_ARRAY_STRIDE: UniformPName read _UNIFORM_ARRAY_STRIDE;
public static property UNIFORM_MATRIX_STRIDE: UniformPName read _UNIFORM_MATRIX_STRIDE;
public static property UNIFORM_IS_ROW_MAJOR: UniformPName read _UNIFORM_IS_ROW_MAJOR;
public static property UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX: UniformPName read _UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX;
public function ToString: string; override;
begin
if self.val = UInt32($8A37) then Result := 'UNIFORM_TYPE' else
if self.val = UInt32($8A38) then Result := 'UNIFORM_SIZE' else
if self.val = UInt32($8A39) then Result := 'UNIFORM_NAME_LENGTH' else
if self.val = UInt32($8A3A) then Result := 'UNIFORM_BLOCK_INDEX' else
if self.val = UInt32($8A3B) then Result := 'UNIFORM_OFFSET' else
if self.val = UInt32($8A3C) then Result := 'UNIFORM_ARRAY_STRIDE' else
if self.val = UInt32($8A3D) then Result := 'UNIFORM_MATRIX_STRIDE' else
if self.val = UInt32($8A3E) then Result := 'UNIFORM_IS_ROW_MAJOR' else
if self.val = UInt32($92DA) then Result := 'UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX' else
Result := self.val.ToString;
end;
end;
UniformType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INT := new UniformType($1404);
private static _UNSIGNED_INT := new UniformType($1405);
private static _FLOAT := new UniformType($1406);
private static _DOUBLE := new UniformType($140A);
private static _FLOAT_VEC2 := new UniformType($8B50);
private static _FLOAT_VEC3 := new UniformType($8B51);
private static _FLOAT_VEC4 := new UniformType($8B52);
private static _INT_VEC2 := new UniformType($8B53);
private static _INT_VEC3 := new UniformType($8B54);
private static _INT_VEC4 := new UniformType($8B55);
private static _BOOL := new UniformType($8B56);
private static _BOOL_VEC2 := new UniformType($8B57);
private static _BOOL_VEC3 := new UniformType($8B58);
private static _BOOL_VEC4 := new UniformType($8B59);
private static _FLOAT_MAT2 := new UniformType($8B5A);
private static _FLOAT_MAT3 := new UniformType($8B5B);
private static _FLOAT_MAT4 := new UniformType($8B5C);
private static _SAMPLER_1D := new UniformType($8B5D);
private static _SAMPLER_2D := new UniformType($8B5E);
private static _SAMPLER_3D := new UniformType($8B5F);
private static _SAMPLER_CUBE := new UniformType($8B60);
private static _SAMPLER_1D_SHADOW := new UniformType($8B61);
private static _SAMPLER_2D_SHADOW := new UniformType($8B62);
private static _SAMPLER_2D_RECT := new UniformType($8B63);
private static _SAMPLER_2D_RECT_SHADOW := new UniformType($8B64);
private static _FLOAT_MAT2x3 := new UniformType($8B65);
private static _FLOAT_MAT2x4 := new UniformType($8B66);
private static _FLOAT_MAT3x2 := new UniformType($8B67);
private static _FLOAT_MAT3x4 := new UniformType($8B68);
private static _FLOAT_MAT4x2 := new UniformType($8B69);
private static _FLOAT_MAT4x3 := new UniformType($8B6A);
private static _SAMPLER_1D_ARRAY := new UniformType($8DC0);
private static _SAMPLER_2D_ARRAY := new UniformType($8DC1);
private static _SAMPLER_BUFFER := new UniformType($8DC2);
private static _SAMPLER_1D_ARRAY_SHADOW := new UniformType($8DC3);
private static _SAMPLER_2D_ARRAY_SHADOW := new UniformType($8DC4);
private static _SAMPLER_CUBE_SHADOW := new UniformType($8DC5);
private static _UNSIGNED_INT_VEC2 := new UniformType($8DC6);
private static _UNSIGNED_INT_VEC3 := new UniformType($8DC7);
private static _UNSIGNED_INT_VEC4 := new UniformType($8DC8);
private static _INT_SAMPLER_1D := new UniformType($8DC9);
private static _INT_SAMPLER_2D := new UniformType($8DCA);
private static _INT_SAMPLER_3D := new UniformType($8DCB);
private static _INT_SAMPLER_CUBE := new UniformType($8DCC);
private static _INT_SAMPLER_2D_RECT := new UniformType($8DCD);
private static _INT_SAMPLER_1D_ARRAY := new UniformType($8DCE);
private static _INT_SAMPLER_2D_ARRAY := new UniformType($8DCF);
private static _INT_SAMPLER_BUFFER := new UniformType($8DD0);
private static _UNSIGNED_INT_SAMPLER_1D := new UniformType($8DD1);
private static _UNSIGNED_INT_SAMPLER_2D := new UniformType($8DD2);
private static _UNSIGNED_INT_SAMPLER_3D := new UniformType($8DD3);
private static _UNSIGNED_INT_SAMPLER_CUBE := new UniformType($8DD4);
private static _UNSIGNED_INT_SAMPLER_2D_RECT := new UniformType($8DD5);
private static _UNSIGNED_INT_SAMPLER_1D_ARRAY := new UniformType($8DD6);
private static _UNSIGNED_INT_SAMPLER_2D_ARRAY := new UniformType($8DD7);
private static _UNSIGNED_INT_SAMPLER_BUFFER := new UniformType($8DD8);
private static _DOUBLE_MAT2 := new UniformType($8F46);
private static _DOUBLE_MAT3 := new UniformType($8F47);
private static _DOUBLE_MAT4 := new UniformType($8F48);
private static _DOUBLE_MAT2x3 := new UniformType($8F49);
private static _DOUBLE_MAT2x4 := new UniformType($8F4A);
private static _DOUBLE_MAT3x2 := new UniformType($8F4B);
private static _DOUBLE_MAT3x4 := new UniformType($8F4C);
private static _DOUBLE_MAT4x2 := new UniformType($8F4D);
private static _DOUBLE_MAT4x3 := new UniformType($8F4E);
private static _DOUBLE_VEC2 := new UniformType($8FFC);
private static _DOUBLE_VEC3 := new UniformType($8FFD);
private static _DOUBLE_VEC4 := new UniformType($8FFE);
private static _SAMPLER_CUBE_MAP_ARRAY := new UniformType($900C);
private static _SAMPLER_CUBE_MAP_ARRAY_SHADOW := new UniformType($900D);
private static _INT_SAMPLER_CUBE_MAP_ARRAY := new UniformType($900E);
private static _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY := new UniformType($900F);
private static _SAMPLER_2D_MULTISAMPLE := new UniformType($9108);
private static _INT_SAMPLER_2D_MULTISAMPLE := new UniformType($9109);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE := new UniformType($910A);
private static _SAMPLER_2D_MULTISAMPLE_ARRAY := new UniformType($910B);
private static _INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new UniformType($910C);
private static _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY := new UniformType($910D);
public static property INT: UniformType read _INT;
public static property UNSIGNED_INT: UniformType read _UNSIGNED_INT;
public static property FLOAT: UniformType read _FLOAT;
public static property DOUBLE: UniformType read _DOUBLE;
public static property FLOAT_VEC2: UniformType read _FLOAT_VEC2;
public static property FLOAT_VEC3: UniformType read _FLOAT_VEC3;
public static property FLOAT_VEC4: UniformType read _FLOAT_VEC4;
public static property INT_VEC2: UniformType read _INT_VEC2;
public static property INT_VEC3: UniformType read _INT_VEC3;
public static property INT_VEC4: UniformType read _INT_VEC4;
public static property BOOL: UniformType read _BOOL;
public static property BOOL_VEC2: UniformType read _BOOL_VEC2;
public static property BOOL_VEC3: UniformType read _BOOL_VEC3;
public static property BOOL_VEC4: UniformType read _BOOL_VEC4;
public static property FLOAT_MAT2: UniformType read _FLOAT_MAT2;
public static property FLOAT_MAT3: UniformType read _FLOAT_MAT3;
public static property FLOAT_MAT4: UniformType read _FLOAT_MAT4;
public static property SAMPLER_1D: UniformType read _SAMPLER_1D;
public static property SAMPLER_2D: UniformType read _SAMPLER_2D;
public static property SAMPLER_3D: UniformType read _SAMPLER_3D;
public static property SAMPLER_CUBE: UniformType read _SAMPLER_CUBE;
public static property SAMPLER_1D_SHADOW: UniformType read _SAMPLER_1D_SHADOW;
public static property SAMPLER_2D_SHADOW: UniformType read _SAMPLER_2D_SHADOW;
public static property SAMPLER_2D_RECT: UniformType read _SAMPLER_2D_RECT;
public static property SAMPLER_2D_RECT_SHADOW: UniformType read _SAMPLER_2D_RECT_SHADOW;
public static property FLOAT_MAT2x3: UniformType read _FLOAT_MAT2x3;
public static property FLOAT_MAT2x4: UniformType read _FLOAT_MAT2x4;
public static property FLOAT_MAT3x2: UniformType read _FLOAT_MAT3x2;
public static property FLOAT_MAT3x4: UniformType read _FLOAT_MAT3x4;
public static property FLOAT_MAT4x2: UniformType read _FLOAT_MAT4x2;
public static property FLOAT_MAT4x3: UniformType read _FLOAT_MAT4x3;
public static property SAMPLER_1D_ARRAY: UniformType read _SAMPLER_1D_ARRAY;
public static property SAMPLER_2D_ARRAY: UniformType read _SAMPLER_2D_ARRAY;
public static property SAMPLER_BUFFER: UniformType read _SAMPLER_BUFFER;
public static property SAMPLER_1D_ARRAY_SHADOW: UniformType read _SAMPLER_1D_ARRAY_SHADOW;
public static property SAMPLER_2D_ARRAY_SHADOW: UniformType read _SAMPLER_2D_ARRAY_SHADOW;
public static property SAMPLER_CUBE_SHADOW: UniformType read _SAMPLER_CUBE_SHADOW;
public static property UNSIGNED_INT_VEC2: UniformType read _UNSIGNED_INT_VEC2;
public static property UNSIGNED_INT_VEC3: UniformType read _UNSIGNED_INT_VEC3;
public static property UNSIGNED_INT_VEC4: UniformType read _UNSIGNED_INT_VEC4;
public static property INT_SAMPLER_1D: UniformType read _INT_SAMPLER_1D;
public static property INT_SAMPLER_2D: UniformType read _INT_SAMPLER_2D;
public static property INT_SAMPLER_3D: UniformType read _INT_SAMPLER_3D;
public static property INT_SAMPLER_CUBE: UniformType read _INT_SAMPLER_CUBE;
public static property INT_SAMPLER_2D_RECT: UniformType read _INT_SAMPLER_2D_RECT;
public static property INT_SAMPLER_1D_ARRAY: UniformType read _INT_SAMPLER_1D_ARRAY;
public static property INT_SAMPLER_2D_ARRAY: UniformType read _INT_SAMPLER_2D_ARRAY;
public static property INT_SAMPLER_BUFFER: UniformType read _INT_SAMPLER_BUFFER;
public static property UNSIGNED_INT_SAMPLER_1D: UniformType read _UNSIGNED_INT_SAMPLER_1D;
public static property UNSIGNED_INT_SAMPLER_2D: UniformType read _UNSIGNED_INT_SAMPLER_2D;
public static property UNSIGNED_INT_SAMPLER_3D: UniformType read _UNSIGNED_INT_SAMPLER_3D;
public static property UNSIGNED_INT_SAMPLER_CUBE: UniformType read _UNSIGNED_INT_SAMPLER_CUBE;
public static property UNSIGNED_INT_SAMPLER_2D_RECT: UniformType read _UNSIGNED_INT_SAMPLER_2D_RECT;
public static property UNSIGNED_INT_SAMPLER_1D_ARRAY: UniformType read _UNSIGNED_INT_SAMPLER_1D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_ARRAY: UniformType read _UNSIGNED_INT_SAMPLER_2D_ARRAY;
public static property UNSIGNED_INT_SAMPLER_BUFFER: UniformType read _UNSIGNED_INT_SAMPLER_BUFFER;
public static property DOUBLE_MAT2: UniformType read _DOUBLE_MAT2;
public static property DOUBLE_MAT3: UniformType read _DOUBLE_MAT3;
public static property DOUBLE_MAT4: UniformType read _DOUBLE_MAT4;
public static property DOUBLE_MAT2x3: UniformType read _DOUBLE_MAT2x3;
public static property DOUBLE_MAT2x4: UniformType read _DOUBLE_MAT2x4;
public static property DOUBLE_MAT3x2: UniformType read _DOUBLE_MAT3x2;
public static property DOUBLE_MAT3x4: UniformType read _DOUBLE_MAT3x4;
public static property DOUBLE_MAT4x2: UniformType read _DOUBLE_MAT4x2;
public static property DOUBLE_MAT4x3: UniformType read _DOUBLE_MAT4x3;
public static property DOUBLE_VEC2: UniformType read _DOUBLE_VEC2;
public static property DOUBLE_VEC3: UniformType read _DOUBLE_VEC3;
public static property DOUBLE_VEC4: UniformType read _DOUBLE_VEC4;
public static property SAMPLER_CUBE_MAP_ARRAY: UniformType read _SAMPLER_CUBE_MAP_ARRAY;
public static property SAMPLER_CUBE_MAP_ARRAY_SHADOW: UniformType read _SAMPLER_CUBE_MAP_ARRAY_SHADOW;
public static property INT_SAMPLER_CUBE_MAP_ARRAY: UniformType read _INT_SAMPLER_CUBE_MAP_ARRAY;
public static property UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: UniformType read _UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY;
public static property SAMPLER_2D_MULTISAMPLE: UniformType read _SAMPLER_2D_MULTISAMPLE;
public static property INT_SAMPLER_2D_MULTISAMPLE: UniformType read _INT_SAMPLER_2D_MULTISAMPLE;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: UniformType read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
public static property SAMPLER_2D_MULTISAMPLE_ARRAY: UniformType read _SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property INT_SAMPLER_2D_MULTISAMPLE_ARRAY: UniformType read _INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public static property UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: UniformType read _UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
public function ToString: string; override;
begin
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($8B50) then Result := 'FLOAT_VEC2' else
if self.val = UInt32($8B51) then Result := 'FLOAT_VEC3' else
if self.val = UInt32($8B52) then Result := 'FLOAT_VEC4' else
if self.val = UInt32($8B53) then Result := 'INT_VEC2' else
if self.val = UInt32($8B54) then Result := 'INT_VEC3' else
if self.val = UInt32($8B55) then Result := 'INT_VEC4' else
if self.val = UInt32($8B56) then Result := 'BOOL' else
if self.val = UInt32($8B57) then Result := 'BOOL_VEC2' else
if self.val = UInt32($8B58) then Result := 'BOOL_VEC3' else
if self.val = UInt32($8B59) then Result := 'BOOL_VEC4' else
if self.val = UInt32($8B5A) then Result := 'FLOAT_MAT2' else
if self.val = UInt32($8B5B) then Result := 'FLOAT_MAT3' else
if self.val = UInt32($8B5C) then Result := 'FLOAT_MAT4' else
if self.val = UInt32($8B5D) then Result := 'SAMPLER_1D' else
if self.val = UInt32($8B5E) then Result := 'SAMPLER_2D' else
if self.val = UInt32($8B5F) then Result := 'SAMPLER_3D' else
if self.val = UInt32($8B60) then Result := 'SAMPLER_CUBE' else
if self.val = UInt32($8B61) then Result := 'SAMPLER_1D_SHADOW' else
if self.val = UInt32($8B62) then Result := 'SAMPLER_2D_SHADOW' else
if self.val = UInt32($8B63) then Result := 'SAMPLER_2D_RECT' else
if self.val = UInt32($8B64) then Result := 'SAMPLER_2D_RECT_SHADOW' else
if self.val = UInt32($8B65) then Result := 'FLOAT_MAT2x3' else
if self.val = UInt32($8B66) then Result := 'FLOAT_MAT2x4' else
if self.val = UInt32($8B67) then Result := 'FLOAT_MAT3x2' else
if self.val = UInt32($8B68) then Result := 'FLOAT_MAT3x4' else
if self.val = UInt32($8B69) then Result := 'FLOAT_MAT4x2' else
if self.val = UInt32($8B6A) then Result := 'FLOAT_MAT4x3' else
if self.val = UInt32($8DC0) then Result := 'SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DC1) then Result := 'SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DC2) then Result := 'SAMPLER_BUFFER' else
if self.val = UInt32($8DC3) then Result := 'SAMPLER_1D_ARRAY_SHADOW' else
if self.val = UInt32($8DC4) then Result := 'SAMPLER_2D_ARRAY_SHADOW' else
if self.val = UInt32($8DC5) then Result := 'SAMPLER_CUBE_SHADOW' else
if self.val = UInt32($8DC6) then Result := 'UNSIGNED_INT_VEC2' else
if self.val = UInt32($8DC7) then Result := 'UNSIGNED_INT_VEC3' else
if self.val = UInt32($8DC8) then Result := 'UNSIGNED_INT_VEC4' else
if self.val = UInt32($8DC9) then Result := 'INT_SAMPLER_1D' else
if self.val = UInt32($8DCA) then Result := 'INT_SAMPLER_2D' else
if self.val = UInt32($8DCB) then Result := 'INT_SAMPLER_3D' else
if self.val = UInt32($8DCC) then Result := 'INT_SAMPLER_CUBE' else
if self.val = UInt32($8DCD) then Result := 'INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DCE) then Result := 'INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DCF) then Result := 'INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD0) then Result := 'INT_SAMPLER_BUFFER' else
if self.val = UInt32($8DD1) then Result := 'UNSIGNED_INT_SAMPLER_1D' else
if self.val = UInt32($8DD2) then Result := 'UNSIGNED_INT_SAMPLER_2D' else
if self.val = UInt32($8DD3) then Result := 'UNSIGNED_INT_SAMPLER_3D' else
if self.val = UInt32($8DD4) then Result := 'UNSIGNED_INT_SAMPLER_CUBE' else
if self.val = UInt32($8DD5) then Result := 'UNSIGNED_INT_SAMPLER_2D_RECT' else
if self.val = UInt32($8DD6) then Result := 'UNSIGNED_INT_SAMPLER_1D_ARRAY' else
if self.val = UInt32($8DD7) then Result := 'UNSIGNED_INT_SAMPLER_2D_ARRAY' else
if self.val = UInt32($8DD8) then Result := 'UNSIGNED_INT_SAMPLER_BUFFER' else
if self.val = UInt32($8F46) then Result := 'DOUBLE_MAT2' else
if self.val = UInt32($8F47) then Result := 'DOUBLE_MAT3' else
if self.val = UInt32($8F48) then Result := 'DOUBLE_MAT4' else
if self.val = UInt32($8F49) then Result := 'DOUBLE_MAT2x3' else
if self.val = UInt32($8F4A) then Result := 'DOUBLE_MAT2x4' else
if self.val = UInt32($8F4B) then Result := 'DOUBLE_MAT3x2' else
if self.val = UInt32($8F4C) then Result := 'DOUBLE_MAT3x4' else
if self.val = UInt32($8F4D) then Result := 'DOUBLE_MAT4x2' else
if self.val = UInt32($8F4E) then Result := 'DOUBLE_MAT4x3' else
if self.val = UInt32($8FFC) then Result := 'DOUBLE_VEC2' else
if self.val = UInt32($8FFD) then Result := 'DOUBLE_VEC3' else
if self.val = UInt32($8FFE) then Result := 'DOUBLE_VEC4' else
if self.val = UInt32($900C) then Result := 'SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900D) then Result := 'SAMPLER_CUBE_MAP_ARRAY_SHADOW' else
if self.val = UInt32($900E) then Result := 'INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($900F) then Result := 'UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY' else
if self.val = UInt32($9108) then Result := 'SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($9109) then Result := 'INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910A) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE' else
if self.val = UInt32($910B) then Result := 'SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910C) then Result := 'INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
if self.val = UInt32($910D) then Result := 'UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY' else
Result := self.val.ToString;
end;
end;
UseProgramStageMask = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_SHADER_BIT := new UseProgramStageMask($0001);
private static _VERTEX_SHADER_BIT_EXT := new UseProgramStageMask($0001);
private static _FRAGMENT_SHADER_BIT := new UseProgramStageMask($0002);
private static _FRAGMENT_SHADER_BIT_EXT := new UseProgramStageMask($0002);
private static _GEOMETRY_SHADER_BIT := new UseProgramStageMask($0004);
private static _GEOMETRY_SHADER_BIT_EXT := new UseProgramStageMask($0004);
private static _GEOMETRY_SHADER_BIT_OES := new UseProgramStageMask($0004);
private static _TESS_CONTROL_SHADER_BIT := new UseProgramStageMask($0008);
private static _TESS_CONTROL_SHADER_BIT_EXT := new UseProgramStageMask($0008);
private static _TESS_CONTROL_SHADER_BIT_OES := new UseProgramStageMask($0008);
private static _TESS_EVALUATION_SHADER_BIT := new UseProgramStageMask($0010);
private static _TESS_EVALUATION_SHADER_BIT_EXT := new UseProgramStageMask($0010);
private static _TESS_EVALUATION_SHADER_BIT_OES := new UseProgramStageMask($0010);
private static _COMPUTE_SHADER_BIT := new UseProgramStageMask($0020);
private static _MESH_SHADER_BIT_NV := new UseProgramStageMask($0040);
private static _TASK_SHADER_BIT_NV := new UseProgramStageMask($0080);
private static _ALL_SHADER_BITS := new UseProgramStageMask($FFFFFFFF);
private static _ALL_SHADER_BITS_EXT := new UseProgramStageMask($FFFFFFFF);
public static property VERTEX_SHADER_BIT: UseProgramStageMask read _VERTEX_SHADER_BIT;
public static property VERTEX_SHADER_BIT_EXT: UseProgramStageMask read _VERTEX_SHADER_BIT_EXT;
public static property FRAGMENT_SHADER_BIT: UseProgramStageMask read _FRAGMENT_SHADER_BIT;
public static property FRAGMENT_SHADER_BIT_EXT: UseProgramStageMask read _FRAGMENT_SHADER_BIT_EXT;
public static property GEOMETRY_SHADER_BIT: UseProgramStageMask read _GEOMETRY_SHADER_BIT;
public static property GEOMETRY_SHADER_BIT_EXT: UseProgramStageMask read _GEOMETRY_SHADER_BIT_EXT;
public static property GEOMETRY_SHADER_BIT_OES: UseProgramStageMask read _GEOMETRY_SHADER_BIT_OES;
public static property TESS_CONTROL_SHADER_BIT: UseProgramStageMask read _TESS_CONTROL_SHADER_BIT;
public static property TESS_CONTROL_SHADER_BIT_EXT: UseProgramStageMask read _TESS_CONTROL_SHADER_BIT_EXT;
public static property TESS_CONTROL_SHADER_BIT_OES: UseProgramStageMask read _TESS_CONTROL_SHADER_BIT_OES;
public static property TESS_EVALUATION_SHADER_BIT: UseProgramStageMask read _TESS_EVALUATION_SHADER_BIT;
public static property TESS_EVALUATION_SHADER_BIT_EXT: UseProgramStageMask read _TESS_EVALUATION_SHADER_BIT_EXT;
public static property TESS_EVALUATION_SHADER_BIT_OES: UseProgramStageMask read _TESS_EVALUATION_SHADER_BIT_OES;
public static property COMPUTE_SHADER_BIT: UseProgramStageMask read _COMPUTE_SHADER_BIT;
public static property MESH_SHADER_BIT_NV: UseProgramStageMask read _MESH_SHADER_BIT_NV;
public static property TASK_SHADER_BIT_NV: UseProgramStageMask read _TASK_SHADER_BIT_NV;
public static property ALL_SHADER_BITS: UseProgramStageMask read _ALL_SHADER_BITS;
public static property ALL_SHADER_BITS_EXT: UseProgramStageMask read _ALL_SHADER_BITS_EXT;
public static function operator or(f1,f2: UseProgramStageMask) := new UseProgramStageMask(f1.val or f2.val);
public property HAS_FLAG_VERTEX_SHADER_BIT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_VERTEX_SHADER_BIT_EXT: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_FRAGMENT_SHADER_BIT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_FRAGMENT_SHADER_BIT_EXT: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_GEOMETRY_SHADER_BIT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_GEOMETRY_SHADER_BIT_EXT: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_GEOMETRY_SHADER_BIT_OES: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_TESS_CONTROL_SHADER_BIT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_TESS_CONTROL_SHADER_BIT_EXT: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_TESS_CONTROL_SHADER_BIT_OES: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_TESS_EVALUATION_SHADER_BIT: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_TESS_EVALUATION_SHADER_BIT_EXT: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_TESS_EVALUATION_SHADER_BIT_OES: boolean read self.val and $0010 <> 0;
public property HAS_FLAG_COMPUTE_SHADER_BIT: boolean read self.val and $0020 <> 0;
public property HAS_FLAG_MESH_SHADER_BIT_NV: boolean read self.val and $0040 <> 0;
public property HAS_FLAG_TASK_SHADER_BIT_NV: boolean read self.val and $0080 <> 0;
public property HAS_FLAG_ALL_SHADER_BITS: boolean read self.val and $FFFFFFFF <> 0;
public property HAS_FLAG_ALL_SHADER_BITS_EXT: boolean read self.val and $FFFFFFFF <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'VERTEX_SHADER_BIT+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'VERTEX_SHADER_BIT_EXT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'FRAGMENT_SHADER_BIT+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'FRAGMENT_SHADER_BIT_EXT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'GEOMETRY_SHADER_BIT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'GEOMETRY_SHADER_BIT_EXT+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'GEOMETRY_SHADER_BIT_OES+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'TESS_CONTROL_SHADER_BIT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'TESS_CONTROL_SHADER_BIT_EXT+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'TESS_CONTROL_SHADER_BIT_OES+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'TESS_EVALUATION_SHADER_BIT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'TESS_EVALUATION_SHADER_BIT_EXT+';
if self.val and UInt32($0010) = UInt32($0010) then res += 'TESS_EVALUATION_SHADER_BIT_OES+';
if self.val and UInt32($0020) = UInt32($0020) then res += 'COMPUTE_SHADER_BIT+';
if self.val and UInt32($0040) = UInt32($0040) then res += 'MESH_SHADER_BIT_NV+';
if self.val and UInt32($0080) = UInt32($0080) then res += 'TASK_SHADER_BIT_NV+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'ALL_SHADER_BITS+';
if self.val and UInt32($FFFFFFFF) = UInt32($FFFFFFFF) then res += 'ALL_SHADER_BITS_EXT+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
VertexArrayPName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_ATTRIB_RELATIVE_OFFSET := new VertexArrayPName($82D5);
private static _VERTEX_ATTRIB_ARRAY_ENABLED := new VertexArrayPName($8622);
private static _VERTEX_ATTRIB_ARRAY_SIZE := new VertexArrayPName($8623);
private static _VERTEX_ATTRIB_ARRAY_STRIDE := new VertexArrayPName($8624);
private static _VERTEX_ATTRIB_ARRAY_TYPE := new VertexArrayPName($8625);
private static _VERTEX_ATTRIB_ARRAY_LONG := new VertexArrayPName($874E);
private static _VERTEX_ATTRIB_ARRAY_NORMALIZED := new VertexArrayPName($886A);
private static _VERTEX_ATTRIB_ARRAY_INTEGER := new VertexArrayPName($88FD);
private static _VERTEX_ATTRIB_ARRAY_DIVISOR := new VertexArrayPName($88FE);
public static property VERTEX_ATTRIB_RELATIVE_OFFSET: VertexArrayPName read _VERTEX_ATTRIB_RELATIVE_OFFSET;
public static property VERTEX_ATTRIB_ARRAY_ENABLED: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_ENABLED;
public static property VERTEX_ATTRIB_ARRAY_SIZE: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_SIZE;
public static property VERTEX_ATTRIB_ARRAY_STRIDE: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_STRIDE;
public static property VERTEX_ATTRIB_ARRAY_TYPE: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_TYPE;
public static property VERTEX_ATTRIB_ARRAY_LONG: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_LONG;
public static property VERTEX_ATTRIB_ARRAY_NORMALIZED: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_NORMALIZED;
public static property VERTEX_ATTRIB_ARRAY_INTEGER: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_INTEGER;
public static property VERTEX_ATTRIB_ARRAY_DIVISOR: VertexArrayPName read _VERTEX_ATTRIB_ARRAY_DIVISOR;
public function ToString: string; override;
begin
if self.val = UInt32($82D5) then Result := 'VERTEX_ATTRIB_RELATIVE_OFFSET' else
if self.val = UInt32($8622) then Result := 'VERTEX_ATTRIB_ARRAY_ENABLED' else
if self.val = UInt32($8623) then Result := 'VERTEX_ATTRIB_ARRAY_SIZE' else
if self.val = UInt32($8624) then Result := 'VERTEX_ATTRIB_ARRAY_STRIDE' else
if self.val = UInt32($8625) then Result := 'VERTEX_ATTRIB_ARRAY_TYPE' else
if self.val = UInt32($874E) then Result := 'VERTEX_ATTRIB_ARRAY_LONG' else
if self.val = UInt32($886A) then Result := 'VERTEX_ATTRIB_ARRAY_NORMALIZED' else
if self.val = UInt32($88FD) then Result := 'VERTEX_ATTRIB_ARRAY_INTEGER' else
if self.val = UInt32($88FE) then Result := 'VERTEX_ATTRIB_ARRAY_DIVISOR' else
Result := self.val.ToString;
end;
end;
VertexAttribEnum = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_ATTRIB_ARRAY_ENABLED := new VertexAttribEnum($8622);
private static _VERTEX_ATTRIB_ARRAY_SIZE := new VertexAttribEnum($8623);
private static _VERTEX_ATTRIB_ARRAY_STRIDE := new VertexAttribEnum($8624);
private static _VERTEX_ATTRIB_ARRAY_TYPE := new VertexAttribEnum($8625);
private static _CURRENT_VERTEX_ATTRIB := new VertexAttribEnum($8626);
private static _VERTEX_ATTRIB_ARRAY_NORMALIZED := new VertexAttribEnum($886A);
private static _VERTEX_ATTRIB_ARRAY_BUFFER_BINDING := new VertexAttribEnum($889F);
private static _VERTEX_ATTRIB_ARRAY_INTEGER := new VertexAttribEnum($88FD);
private static _VERTEX_ATTRIB_ARRAY_DIVISOR := new VertexAttribEnum($88FE);
public static property VERTEX_ATTRIB_ARRAY_ENABLED: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_ENABLED;
public static property VERTEX_ATTRIB_ARRAY_SIZE: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_SIZE;
public static property VERTEX_ATTRIB_ARRAY_STRIDE: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_STRIDE;
public static property VERTEX_ATTRIB_ARRAY_TYPE: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_TYPE;
public static property CURRENT_VERTEX_ATTRIB: VertexAttribEnum read _CURRENT_VERTEX_ATTRIB;
public static property VERTEX_ATTRIB_ARRAY_NORMALIZED: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_NORMALIZED;
public static property VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_BUFFER_BINDING;
public static property VERTEX_ATTRIB_ARRAY_INTEGER: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_INTEGER;
public static property VERTEX_ATTRIB_ARRAY_DIVISOR: VertexAttribEnum read _VERTEX_ATTRIB_ARRAY_DIVISOR;
public function ToString: string; override;
begin
if self.val = UInt32($8622) then Result := 'VERTEX_ATTRIB_ARRAY_ENABLED' else
if self.val = UInt32($8623) then Result := 'VERTEX_ATTRIB_ARRAY_SIZE' else
if self.val = UInt32($8624) then Result := 'VERTEX_ATTRIB_ARRAY_STRIDE' else
if self.val = UInt32($8625) then Result := 'VERTEX_ATTRIB_ARRAY_TYPE' else
if self.val = UInt32($8626) then Result := 'CURRENT_VERTEX_ATTRIB' else
if self.val = UInt32($886A) then Result := 'VERTEX_ATTRIB_ARRAY_NORMALIZED' else
if self.val = UInt32($889F) then Result := 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING' else
if self.val = UInt32($88FD) then Result := 'VERTEX_ATTRIB_ARRAY_INTEGER' else
if self.val = UInt32($88FE) then Result := 'VERTEX_ATTRIB_ARRAY_DIVISOR' else
Result := self.val.ToString;
end;
end;
VertexAttribIType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new VertexAttribIType($1400);
private static _UNSIGNED_BYTE := new VertexAttribIType($1401);
private static _SHORT := new VertexAttribIType($1402);
private static _UNSIGNED_SHORT := new VertexAttribIType($1403);
private static _INT := new VertexAttribIType($1404);
private static _UNSIGNED_INT := new VertexAttribIType($1405);
public static property BYTE: VertexAttribIType read _BYTE;
public static property UNSIGNED_BYTE: VertexAttribIType read _UNSIGNED_BYTE;
public static property SHORT: VertexAttribIType read _SHORT;
public static property UNSIGNED_SHORT: VertexAttribIType read _UNSIGNED_SHORT;
public static property INT: VertexAttribIType read _INT;
public static property UNSIGNED_INT: VertexAttribIType read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
VertexAttribLType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DOUBLE := new VertexAttribLType($140A);
public static property DOUBLE: VertexAttribLType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
VertexAttribPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new VertexAttribPointerType($1400);
private static _UNSIGNED_BYTE := new VertexAttribPointerType($1401);
private static _SHORT := new VertexAttribPointerType($1402);
private static _UNSIGNED_SHORT := new VertexAttribPointerType($1403);
private static _INT := new VertexAttribPointerType($1404);
private static _UNSIGNED_INT := new VertexAttribPointerType($1405);
private static _FLOAT := new VertexAttribPointerType($1406);
private static _DOUBLE := new VertexAttribPointerType($140A);
private static _HALF_FLOAT := new VertexAttribPointerType($140B);
private static _FIXED := new VertexAttribPointerType($140C);
private static _INT64_ARB := new VertexAttribPointerType($140E);
private static _INT64_NV := new VertexAttribPointerType($140E);
private static _UNSIGNED_INT64_ARB := new VertexAttribPointerType($140F);
private static _UNSIGNED_INT64_NV := new VertexAttribPointerType($140F);
private static _UNSIGNED_INT_2_10_10_10_REV := new VertexAttribPointerType($8368);
private static _UNSIGNED_INT_10F_11F_11F_REV := new VertexAttribPointerType($8C3B);
private static _INT_2_10_10_10_REV := new VertexAttribPointerType($8D9F);
public static property BYTE: VertexAttribPointerType read _BYTE;
public static property UNSIGNED_BYTE: VertexAttribPointerType read _UNSIGNED_BYTE;
public static property SHORT: VertexAttribPointerType read _SHORT;
public static property UNSIGNED_SHORT: VertexAttribPointerType read _UNSIGNED_SHORT;
public static property INT: VertexAttribPointerType read _INT;
public static property UNSIGNED_INT: VertexAttribPointerType read _UNSIGNED_INT;
public static property FLOAT: VertexAttribPointerType read _FLOAT;
public static property DOUBLE: VertexAttribPointerType read _DOUBLE;
public static property HALF_FLOAT: VertexAttribPointerType read _HALF_FLOAT;
public static property FIXED: VertexAttribPointerType read _FIXED;
public static property INT64_ARB: VertexAttribPointerType read _INT64_ARB;
public static property INT64_NV: VertexAttribPointerType read _INT64_NV;
public static property UNSIGNED_INT64_ARB: VertexAttribPointerType read _UNSIGNED_INT64_ARB;
public static property UNSIGNED_INT64_NV: VertexAttribPointerType read _UNSIGNED_INT64_NV;
public static property UNSIGNED_INT_2_10_10_10_REV: VertexAttribPointerType read _UNSIGNED_INT_2_10_10_10_REV;
public static property UNSIGNED_INT_10F_11F_11F_REV: VertexAttribPointerType read _UNSIGNED_INT_10F_11F_11F_REV;
public static property INT_2_10_10_10_REV: VertexAttribPointerType read _INT_2_10_10_10_REV;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($140B) then Result := 'HALF_FLOAT' else
if self.val = UInt32($140C) then Result := 'FIXED' else
if self.val = UInt32($140E) then Result := 'INT64_ARB' else
if self.val = UInt32($140E) then Result := 'INT64_NV' else
if self.val = UInt32($140F) then Result := 'UNSIGNED_INT64_ARB' else
if self.val = UInt32($140F) then Result := 'UNSIGNED_INT64_NV' else
if self.val = UInt32($8368) then Result := 'UNSIGNED_INT_2_10_10_10_REV' else
if self.val = UInt32($8C3B) then Result := 'UNSIGNED_INT_10F_11F_11F_REV' else
if self.val = UInt32($8D9F) then Result := 'INT_2_10_10_10_REV' else
Result := self.val.ToString;
end;
end;
VertexAttribType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new VertexAttribType($1400);
private static _UNSIGNED_BYTE := new VertexAttribType($1401);
private static _SHORT := new VertexAttribType($1402);
private static _UNSIGNED_SHORT := new VertexAttribType($1403);
private static _INT := new VertexAttribType($1404);
private static _UNSIGNED_INT := new VertexAttribType($1405);
private static _FLOAT := new VertexAttribType($1406);
private static _DOUBLE := new VertexAttribType($140A);
private static _HALF_FLOAT := new VertexAttribType($140B);
private static _FIXED := new VertexAttribType($140C);
private static _UNSIGNED_INT_2_10_10_10_REV := new VertexAttribType($8368);
private static _UNSIGNED_INT_10F_11F_11F_REV := new VertexAttribType($8C3B);
private static _INT_2_10_10_10_REV := new VertexAttribType($8D9F);
public static property BYTE: VertexAttribType read _BYTE;
public static property UNSIGNED_BYTE: VertexAttribType read _UNSIGNED_BYTE;
public static property SHORT: VertexAttribType read _SHORT;
public static property UNSIGNED_SHORT: VertexAttribType read _UNSIGNED_SHORT;
public static property INT: VertexAttribType read _INT;
public static property UNSIGNED_INT: VertexAttribType read _UNSIGNED_INT;
public static property FLOAT: VertexAttribType read _FLOAT;
public static property DOUBLE: VertexAttribType read _DOUBLE;
public static property HALF_FLOAT: VertexAttribType read _HALF_FLOAT;
public static property FIXED: VertexAttribType read _FIXED;
public static property UNSIGNED_INT_2_10_10_10_REV: VertexAttribType read _UNSIGNED_INT_2_10_10_10_REV;
public static property UNSIGNED_INT_10F_11F_11F_REV: VertexAttribType read _UNSIGNED_INT_10F_11F_11F_REV;
public static property INT_2_10_10_10_REV: VertexAttribType read _INT_2_10_10_10_REV;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($140B) then Result := 'HALF_FLOAT' else
if self.val = UInt32($140C) then Result := 'FIXED' else
if self.val = UInt32($8368) then Result := 'UNSIGNED_INT_2_10_10_10_REV' else
if self.val = UInt32($8C3B) then Result := 'UNSIGNED_INT_10F_11F_11F_REV' else
if self.val = UInt32($8D9F) then Result := 'INT_2_10_10_10_REV' else
Result := self.val.ToString;
end;
end;
VertexBufferObjectParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BUFFER_IMMUTABLE_STORAGE := new VertexBufferObjectParameter($821F);
private static _BUFFER_STORAGE_FLAGS := new VertexBufferObjectParameter($8220);
private static _BUFFER_SIZE := new VertexBufferObjectParameter($8764);
private static _BUFFER_USAGE := new VertexBufferObjectParameter($8765);
private static _BUFFER_ACCESS := new VertexBufferObjectParameter($88BB);
private static _BUFFER_MAPPED := new VertexBufferObjectParameter($88BC);
private static _BUFFER_ACCESS_FLAGS := new VertexBufferObjectParameter($911F);
private static _BUFFER_MAP_LENGTH := new VertexBufferObjectParameter($9120);
private static _BUFFER_MAP_OFFSET := new VertexBufferObjectParameter($9121);
public static property BUFFER_IMMUTABLE_STORAGE: VertexBufferObjectParameter read _BUFFER_IMMUTABLE_STORAGE;
public static property BUFFER_STORAGE_FLAGS: VertexBufferObjectParameter read _BUFFER_STORAGE_FLAGS;
public static property BUFFER_SIZE: VertexBufferObjectParameter read _BUFFER_SIZE;
public static property BUFFER_USAGE: VertexBufferObjectParameter read _BUFFER_USAGE;
public static property BUFFER_ACCESS: VertexBufferObjectParameter read _BUFFER_ACCESS;
public static property BUFFER_MAPPED: VertexBufferObjectParameter read _BUFFER_MAPPED;
public static property BUFFER_ACCESS_FLAGS: VertexBufferObjectParameter read _BUFFER_ACCESS_FLAGS;
public static property BUFFER_MAP_LENGTH: VertexBufferObjectParameter read _BUFFER_MAP_LENGTH;
public static property BUFFER_MAP_OFFSET: VertexBufferObjectParameter read _BUFFER_MAP_OFFSET;
public function ToString: string; override;
begin
if self.val = UInt32($821F) then Result := 'BUFFER_IMMUTABLE_STORAGE' else
if self.val = UInt32($8220) then Result := 'BUFFER_STORAGE_FLAGS' else
if self.val = UInt32($8764) then Result := 'BUFFER_SIZE' else
if self.val = UInt32($8765) then Result := 'BUFFER_USAGE' else
if self.val = UInt32($88BB) then Result := 'BUFFER_ACCESS' else
if self.val = UInt32($88BC) then Result := 'BUFFER_MAPPED' else
if self.val = UInt32($911F) then Result := 'BUFFER_ACCESS_FLAGS' else
if self.val = UInt32($9120) then Result := 'BUFFER_MAP_LENGTH' else
if self.val = UInt32($9121) then Result := 'BUFFER_MAP_OFFSET' else
Result := self.val.ToString;
end;
end;
VertexBufferObjectUsage = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STREAM_DRAW := new VertexBufferObjectUsage($88E0);
private static _STREAM_READ := new VertexBufferObjectUsage($88E1);
private static _STREAM_COPY := new VertexBufferObjectUsage($88E2);
private static _STATIC_DRAW := new VertexBufferObjectUsage($88E4);
private static _STATIC_READ := new VertexBufferObjectUsage($88E5);
private static _STATIC_COPY := new VertexBufferObjectUsage($88E6);
private static _DYNAMIC_DRAW := new VertexBufferObjectUsage($88E8);
private static _DYNAMIC_READ := new VertexBufferObjectUsage($88E9);
private static _DYNAMIC_COPY := new VertexBufferObjectUsage($88EA);
public static property STREAM_DRAW: VertexBufferObjectUsage read _STREAM_DRAW;
public static property STREAM_READ: VertexBufferObjectUsage read _STREAM_READ;
public static property STREAM_COPY: VertexBufferObjectUsage read _STREAM_COPY;
public static property STATIC_DRAW: VertexBufferObjectUsage read _STATIC_DRAW;
public static property STATIC_READ: VertexBufferObjectUsage read _STATIC_READ;
public static property STATIC_COPY: VertexBufferObjectUsage read _STATIC_COPY;
public static property DYNAMIC_DRAW: VertexBufferObjectUsage read _DYNAMIC_DRAW;
public static property DYNAMIC_READ: VertexBufferObjectUsage read _DYNAMIC_READ;
public static property DYNAMIC_COPY: VertexBufferObjectUsage read _DYNAMIC_COPY;
public function ToString: string; override;
begin
if self.val = UInt32($88E0) then Result := 'STREAM_DRAW' else
if self.val = UInt32($88E1) then Result := 'STREAM_READ' else
if self.val = UInt32($88E2) then Result := 'STREAM_COPY' else
if self.val = UInt32($88E4) then Result := 'STATIC_DRAW' else
if self.val = UInt32($88E5) then Result := 'STATIC_READ' else
if self.val = UInt32($88E6) then Result := 'STATIC_COPY' else
if self.val = UInt32($88E8) then Result := 'DYNAMIC_DRAW' else
if self.val = UInt32($88E9) then Result := 'DYNAMIC_READ' else
if self.val = UInt32($88EA) then Result := 'DYNAMIC_COPY' else
Result := self.val.ToString;
end;
end;
VertexPointerType = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SHORT := new VertexPointerType($1402);
private static _INT := new VertexPointerType($1404);
private static _FLOAT := new VertexPointerType($1406);
private static _DOUBLE := new VertexPointerType($140A);
public static property SHORT: VertexPointerType read _SHORT;
public static property INT: VertexPointerType read _INT;
public static property FLOAT: VertexPointerType read _FLOAT;
public static property DOUBLE: VertexPointerType read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
VertexProvokingMode = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FIRST_VERTEX_CONVENTION := new VertexProvokingMode($8E4D);
private static _LAST_VERTEX_CONVENTION := new VertexProvokingMode($8E4E);
public static property FIRST_VERTEX_CONVENTION: VertexProvokingMode read _FIRST_VERTEX_CONVENTION;
public static property LAST_VERTEX_CONVENTION: VertexProvokingMode read _LAST_VERTEX_CONVENTION;
public function ToString: string; override;
begin
if self.val = UInt32($8E4D) then Result := 'FIRST_VERTEX_CONVENTION' else
if self.val = UInt32($8E4E) then Result := 'LAST_VERTEX_CONVENTION' else
Result := self.val.ToString;
end;
end;
VertexShaderTextureUnitParameter = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CURRENT_TEXTURE_COORDS := new VertexShaderTextureUnitParameter($0B03);
private static _TEXTURE_MATRIX := new VertexShaderTextureUnitParameter($0BA8);
public static property CURRENT_TEXTURE_COORDS: VertexShaderTextureUnitParameter read _CURRENT_TEXTURE_COORDS;
public static property TEXTURE_MATRIX: VertexShaderTextureUnitParameter read _TEXTURE_MATRIX;
public function ToString: string; override;
begin
if self.val = UInt32($0B03) then Result := 'CURRENT_TEXTURE_COORDS' else
if self.val = UInt32($0BA8) then Result := 'TEXTURE_MATRIX' else
Result := self.val.ToString;
end;
end;
{$endregion Core}
{$region ARB}
BufferAccessARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _READ_ONLY := new BufferAccessARB($88B8);
private static _WRITE_ONLY := new BufferAccessARB($88B9);
private static _READ_WRITE := new BufferAccessARB($88BA);
public static property READ_ONLY: BufferAccessARB read _READ_ONLY;
public static property WRITE_ONLY: BufferAccessARB read _WRITE_ONLY;
public static property READ_WRITE: BufferAccessARB read _READ_WRITE;
public function ToString: string; override;
begin
if self.val = UInt32($88B8) then Result := 'READ_ONLY' else
if self.val = UInt32($88B9) then Result := 'WRITE_ONLY' else
if self.val = UInt32($88BA) then Result := 'READ_WRITE' else
Result := self.val.ToString;
end;
end;
BufferPNameARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BUFFER_IMMUTABLE_STORAGE := new BufferPNameARB($821F);
private static _BUFFER_STORAGE_FLAGS := new BufferPNameARB($8220);
private static _BUFFER_SIZE := new BufferPNameARB($8764);
private static _BUFFER_SIZE_ARB := new BufferPNameARB($8764);
private static _BUFFER_USAGE := new BufferPNameARB($8765);
private static _BUFFER_USAGE_ARB := new BufferPNameARB($8765);
private static _BUFFER_ACCESS := new BufferPNameARB($88BB);
private static _BUFFER_ACCESS_ARB := new BufferPNameARB($88BB);
private static _BUFFER_MAPPED := new BufferPNameARB($88BC);
private static _BUFFER_MAPPED_ARB := new BufferPNameARB($88BC);
private static _BUFFER_ACCESS_FLAGS := new BufferPNameARB($911F);
private static _BUFFER_MAP_LENGTH := new BufferPNameARB($9120);
private static _BUFFER_MAP_OFFSET := new BufferPNameARB($9121);
public static property BUFFER_IMMUTABLE_STORAGE: BufferPNameARB read _BUFFER_IMMUTABLE_STORAGE;
public static property BUFFER_STORAGE_FLAGS: BufferPNameARB read _BUFFER_STORAGE_FLAGS;
public static property BUFFER_SIZE: BufferPNameARB read _BUFFER_SIZE;
public static property BUFFER_SIZE_ARB: BufferPNameARB read _BUFFER_SIZE_ARB;
public static property BUFFER_USAGE: BufferPNameARB read _BUFFER_USAGE;
public static property BUFFER_USAGE_ARB: BufferPNameARB read _BUFFER_USAGE_ARB;
public static property BUFFER_ACCESS: BufferPNameARB read _BUFFER_ACCESS;
public static property BUFFER_ACCESS_ARB: BufferPNameARB read _BUFFER_ACCESS_ARB;
public static property BUFFER_MAPPED: BufferPNameARB read _BUFFER_MAPPED;
public static property BUFFER_MAPPED_ARB: BufferPNameARB read _BUFFER_MAPPED_ARB;
public static property BUFFER_ACCESS_FLAGS: BufferPNameARB read _BUFFER_ACCESS_FLAGS;
public static property BUFFER_MAP_LENGTH: BufferPNameARB read _BUFFER_MAP_LENGTH;
public static property BUFFER_MAP_OFFSET: BufferPNameARB read _BUFFER_MAP_OFFSET;
public function ToString: string; override;
begin
if self.val = UInt32($821F) then Result := 'BUFFER_IMMUTABLE_STORAGE' else
if self.val = UInt32($8220) then Result := 'BUFFER_STORAGE_FLAGS' else
if self.val = UInt32($8764) then Result := 'BUFFER_SIZE' else
if self.val = UInt32($8764) then Result := 'BUFFER_SIZE_ARB' else
if self.val = UInt32($8765) then Result := 'BUFFER_USAGE' else
if self.val = UInt32($8765) then Result := 'BUFFER_USAGE_ARB' else
if self.val = UInt32($88BB) then Result := 'BUFFER_ACCESS' else
if self.val = UInt32($88BB) then Result := 'BUFFER_ACCESS_ARB' else
if self.val = UInt32($88BC) then Result := 'BUFFER_MAPPED' else
if self.val = UInt32($88BC) then Result := 'BUFFER_MAPPED_ARB' else
if self.val = UInt32($911F) then Result := 'BUFFER_ACCESS_FLAGS' else
if self.val = UInt32($9120) then Result := 'BUFFER_MAP_LENGTH' else
if self.val = UInt32($9121) then Result := 'BUFFER_MAP_OFFSET' else
Result := self.val.ToString;
end;
end;
BufferPointerNameARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BUFFER_MAP_POINTER := new BufferPointerNameARB($88BD);
private static _BUFFER_MAP_POINTER_ARB := new BufferPointerNameARB($88BD);
public static property BUFFER_MAP_POINTER: BufferPointerNameARB read _BUFFER_MAP_POINTER;
public static property BUFFER_MAP_POINTER_ARB: BufferPointerNameARB read _BUFFER_MAP_POINTER_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($88BD) then Result := 'BUFFER_MAP_POINTER' else
if self.val = UInt32($88BD) then Result := 'BUFFER_MAP_POINTER_ARB' else
Result := self.val.ToString;
end;
end;
BufferTargetARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PARAMETER_BUFFER := new BufferTargetARB($80EE);
private static _ARRAY_BUFFER := new BufferTargetARB($8892);
private static _ELEMENT_ARRAY_BUFFER := new BufferTargetARB($8893);
private static _PIXEL_PACK_BUFFER := new BufferTargetARB($88EB);
private static _PIXEL_UNPACK_BUFFER := new BufferTargetARB($88EC);
private static _UNIFORM_BUFFER := new BufferTargetARB($8A11);
private static _TEXTURE_BUFFER := new BufferTargetARB($8C2A);
private static _TRANSFORM_FEEDBACK_BUFFER := new BufferTargetARB($8C8E);
private static _COPY_READ_BUFFER := new BufferTargetARB($8F36);
private static _COPY_WRITE_BUFFER := new BufferTargetARB($8F37);
private static _DRAW_INDIRECT_BUFFER := new BufferTargetARB($8F3F);
private static _SHADER_STORAGE_BUFFER := new BufferTargetARB($90D2);
private static _DISPATCH_INDIRECT_BUFFER := new BufferTargetARB($90EE);
private static _QUERY_BUFFER := new BufferTargetARB($9192);
private static _ATOMIC_COUNTER_BUFFER := new BufferTargetARB($92C0);
public static property PARAMETER_BUFFER: BufferTargetARB read _PARAMETER_BUFFER;
public static property ARRAY_BUFFER: BufferTargetARB read _ARRAY_BUFFER;
public static property ELEMENT_ARRAY_BUFFER: BufferTargetARB read _ELEMENT_ARRAY_BUFFER;
public static property PIXEL_PACK_BUFFER: BufferTargetARB read _PIXEL_PACK_BUFFER;
public static property PIXEL_UNPACK_BUFFER: BufferTargetARB read _PIXEL_UNPACK_BUFFER;
public static property UNIFORM_BUFFER: BufferTargetARB read _UNIFORM_BUFFER;
public static property TEXTURE_BUFFER: BufferTargetARB read _TEXTURE_BUFFER;
public static property TRANSFORM_FEEDBACK_BUFFER: BufferTargetARB read _TRANSFORM_FEEDBACK_BUFFER;
public static property COPY_READ_BUFFER: BufferTargetARB read _COPY_READ_BUFFER;
public static property COPY_WRITE_BUFFER: BufferTargetARB read _COPY_WRITE_BUFFER;
public static property DRAW_INDIRECT_BUFFER: BufferTargetARB read _DRAW_INDIRECT_BUFFER;
public static property SHADER_STORAGE_BUFFER: BufferTargetARB read _SHADER_STORAGE_BUFFER;
public static property DISPATCH_INDIRECT_BUFFER: BufferTargetARB read _DISPATCH_INDIRECT_BUFFER;
public static property QUERY_BUFFER: BufferTargetARB read _QUERY_BUFFER;
public static property ATOMIC_COUNTER_BUFFER: BufferTargetARB read _ATOMIC_COUNTER_BUFFER;
public function ToString: string; override;
begin
if self.val = UInt32($80EE) then Result := 'PARAMETER_BUFFER' else
if self.val = UInt32($8892) then Result := 'ARRAY_BUFFER' else
if self.val = UInt32($8893) then Result := 'ELEMENT_ARRAY_BUFFER' else
if self.val = UInt32($88EB) then Result := 'PIXEL_PACK_BUFFER' else
if self.val = UInt32($88EC) then Result := 'PIXEL_UNPACK_BUFFER' else
if self.val = UInt32($8A11) then Result := 'UNIFORM_BUFFER' else
if self.val = UInt32($8C2A) then Result := 'TEXTURE_BUFFER' else
if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
if self.val = UInt32($8F36) then Result := 'COPY_READ_BUFFER' else
if self.val = UInt32($8F37) then Result := 'COPY_WRITE_BUFFER' else
if self.val = UInt32($8F3F) then Result := 'DRAW_INDIRECT_BUFFER' else
if self.val = UInt32($90D2) then Result := 'SHADER_STORAGE_BUFFER' else
if self.val = UInt32($90EE) then Result := 'DISPATCH_INDIRECT_BUFFER' else
if self.val = UInt32($9192) then Result := 'QUERY_BUFFER' else
if self.val = UInt32($92C0) then Result := 'ATOMIC_COUNTER_BUFFER' else
Result := self.val.ToString;
end;
end;
BufferUsageARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STREAM_DRAW := new BufferUsageARB($88E0);
private static _STREAM_READ := new BufferUsageARB($88E1);
private static _STREAM_COPY := new BufferUsageARB($88E2);
private static _STATIC_DRAW := new BufferUsageARB($88E4);
private static _STATIC_READ := new BufferUsageARB($88E5);
private static _STATIC_COPY := new BufferUsageARB($88E6);
private static _DYNAMIC_DRAW := new BufferUsageARB($88E8);
private static _DYNAMIC_READ := new BufferUsageARB($88E9);
private static _DYNAMIC_COPY := new BufferUsageARB($88EA);
public static property STREAM_DRAW: BufferUsageARB read _STREAM_DRAW;
public static property STREAM_READ: BufferUsageARB read _STREAM_READ;
public static property STREAM_COPY: BufferUsageARB read _STREAM_COPY;
public static property STATIC_DRAW: BufferUsageARB read _STATIC_DRAW;
public static property STATIC_READ: BufferUsageARB read _STATIC_READ;
public static property STATIC_COPY: BufferUsageARB read _STATIC_COPY;
public static property DYNAMIC_DRAW: BufferUsageARB read _DYNAMIC_DRAW;
public static property DYNAMIC_READ: BufferUsageARB read _DYNAMIC_READ;
public static property DYNAMIC_COPY: BufferUsageARB read _DYNAMIC_COPY;
public function ToString: string; override;
begin
if self.val = UInt32($88E0) then Result := 'STREAM_DRAW' else
if self.val = UInt32($88E1) then Result := 'STREAM_READ' else
if self.val = UInt32($88E2) then Result := 'STREAM_COPY' else
if self.val = UInt32($88E4) then Result := 'STATIC_DRAW' else
if self.val = UInt32($88E5) then Result := 'STATIC_READ' else
if self.val = UInt32($88E6) then Result := 'STATIC_COPY' else
if self.val = UInt32($88E8) then Result := 'DYNAMIC_DRAW' else
if self.val = UInt32($88E9) then Result := 'DYNAMIC_READ' else
if self.val = UInt32($88EA) then Result := 'DYNAMIC_COPY' else
Result := self.val.ToString;
end;
end;
ClampColorModeARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FALSE := new ClampColorModeARB($0000);
private static _TRUE := new ClampColorModeARB($0001);
private static _FIXED_ONLY := new ClampColorModeARB($891D);
private static _FIXED_ONLY_ARB := new ClampColorModeARB($891D);
public static property FALSE: ClampColorModeARB read _FALSE;
public static property TRUE: ClampColorModeARB read _TRUE;
public static property FIXED_ONLY: ClampColorModeARB read _FIXED_ONLY;
public static property FIXED_ONLY_ARB: ClampColorModeARB read _FIXED_ONLY_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'FALSE' else
if self.val = UInt32($0001) then Result := 'TRUE' else
if self.val = UInt32($891D) then Result := 'FIXED_ONLY' else
if self.val = UInt32($891D) then Result := 'FIXED_ONLY_ARB' else
Result := self.val.ToString;
end;
end;
ClampColorTargetARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CLAMP_VERTEX_COLOR_ARB := new ClampColorTargetARB($891A);
private static _CLAMP_FRAGMENT_COLOR_ARB := new ClampColorTargetARB($891B);
private static _CLAMP_READ_COLOR := new ClampColorTargetARB($891C);
private static _CLAMP_READ_COLOR_ARB := new ClampColorTargetARB($891C);
public static property CLAMP_VERTEX_COLOR_ARB: ClampColorTargetARB read _CLAMP_VERTEX_COLOR_ARB;
public static property CLAMP_FRAGMENT_COLOR_ARB: ClampColorTargetARB read _CLAMP_FRAGMENT_COLOR_ARB;
public static property CLAMP_READ_COLOR: ClampColorTargetARB read _CLAMP_READ_COLOR;
public static property CLAMP_READ_COLOR_ARB: ClampColorTargetARB read _CLAMP_READ_COLOR_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($891A) then Result := 'CLAMP_VERTEX_COLOR_ARB' else
if self.val = UInt32($891B) then Result := 'CLAMP_FRAGMENT_COLOR_ARB' else
if self.val = UInt32($891C) then Result := 'CLAMP_READ_COLOR' else
if self.val = UInt32($891C) then Result := 'CLAMP_READ_COLOR_ARB' else
Result := self.val.ToString;
end;
end;
MatrixIndexPointerTypeARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_BYTE := new MatrixIndexPointerTypeARB($1401);
private static _UNSIGNED_SHORT := new MatrixIndexPointerTypeARB($1403);
private static _UNSIGNED_INT := new MatrixIndexPointerTypeARB($1405);
public static property UNSIGNED_BYTE: MatrixIndexPointerTypeARB read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: MatrixIndexPointerTypeARB read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: MatrixIndexPointerTypeARB read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
PointParameterNameARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _POINT_SIZE_MIN_EXT := new PointParameterNameARB($8126);
private static _POINT_SIZE_MAX_EXT := new PointParameterNameARB($8127);
private static _POINT_FADE_THRESHOLD_SIZE := new PointParameterNameARB($8128);
private static _POINT_FADE_THRESHOLD_SIZE_EXT := new PointParameterNameARB($8128);
public static property POINT_SIZE_MIN_EXT: PointParameterNameARB read _POINT_SIZE_MIN_EXT;
public static property POINT_SIZE_MAX_EXT: PointParameterNameARB read _POINT_SIZE_MAX_EXT;
public static property POINT_FADE_THRESHOLD_SIZE: PointParameterNameARB read _POINT_FADE_THRESHOLD_SIZE;
public static property POINT_FADE_THRESHOLD_SIZE_EXT: PointParameterNameARB read _POINT_FADE_THRESHOLD_SIZE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8126) then Result := 'POINT_SIZE_MIN_EXT' else
if self.val = UInt32($8127) then Result := 'POINT_SIZE_MAX_EXT' else
if self.val = UInt32($8128) then Result := 'POINT_FADE_THRESHOLD_SIZE' else
if self.val = UInt32($8128) then Result := 'POINT_FADE_THRESHOLD_SIZE_EXT' else
Result := self.val.ToString;
end;
end;
ProgramPropertyARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COMPUTE_WORK_GROUP_SIZE := new ProgramPropertyARB($8267);
private static _PROGRAM_BINARY_LENGTH := new ProgramPropertyARB($8741);
private static _GEOMETRY_VERTICES_OUT := new ProgramPropertyARB($8916);
private static _GEOMETRY_INPUT_TYPE := new ProgramPropertyARB($8917);
private static _GEOMETRY_OUTPUT_TYPE := new ProgramPropertyARB($8918);
private static _ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH := new ProgramPropertyARB($8A35);
private static _ACTIVE_UNIFORM_BLOCKS := new ProgramPropertyARB($8A36);
private static _DELETE_STATUS := new ProgramPropertyARB($8B80);
private static _LINK_STATUS := new ProgramPropertyARB($8B82);
private static _VALIDATE_STATUS := new ProgramPropertyARB($8B83);
private static _INFO_LOG_LENGTH := new ProgramPropertyARB($8B84);
private static _ATTACHED_SHADERS := new ProgramPropertyARB($8B85);
private static _ACTIVE_UNIFORMS := new ProgramPropertyARB($8B86);
private static _ACTIVE_UNIFORM_MAX_LENGTH := new ProgramPropertyARB($8B87);
private static _ACTIVE_ATTRIBUTES := new ProgramPropertyARB($8B89);
private static _ACTIVE_ATTRIBUTE_MAX_LENGTH := new ProgramPropertyARB($8B8A);
private static _TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH := new ProgramPropertyARB($8C76);
private static _TRANSFORM_FEEDBACK_BUFFER_MODE := new ProgramPropertyARB($8C7F);
private static _TRANSFORM_FEEDBACK_VARYINGS := new ProgramPropertyARB($8C83);
private static _ACTIVE_ATOMIC_COUNTER_BUFFERS := new ProgramPropertyARB($92D9);
public static property COMPUTE_WORK_GROUP_SIZE: ProgramPropertyARB read _COMPUTE_WORK_GROUP_SIZE;
public static property PROGRAM_BINARY_LENGTH: ProgramPropertyARB read _PROGRAM_BINARY_LENGTH;
public static property GEOMETRY_VERTICES_OUT: ProgramPropertyARB read _GEOMETRY_VERTICES_OUT;
public static property GEOMETRY_INPUT_TYPE: ProgramPropertyARB read _GEOMETRY_INPUT_TYPE;
public static property GEOMETRY_OUTPUT_TYPE: ProgramPropertyARB read _GEOMETRY_OUTPUT_TYPE;
public static property ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: ProgramPropertyARB read _ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH;
public static property ACTIVE_UNIFORM_BLOCKS: ProgramPropertyARB read _ACTIVE_UNIFORM_BLOCKS;
public static property DELETE_STATUS: ProgramPropertyARB read _DELETE_STATUS;
public static property LINK_STATUS: ProgramPropertyARB read _LINK_STATUS;
public static property VALIDATE_STATUS: ProgramPropertyARB read _VALIDATE_STATUS;
public static property INFO_LOG_LENGTH: ProgramPropertyARB read _INFO_LOG_LENGTH;
public static property ATTACHED_SHADERS: ProgramPropertyARB read _ATTACHED_SHADERS;
public static property ACTIVE_UNIFORMS: ProgramPropertyARB read _ACTIVE_UNIFORMS;
public static property ACTIVE_UNIFORM_MAX_LENGTH: ProgramPropertyARB read _ACTIVE_UNIFORM_MAX_LENGTH;
public static property ACTIVE_ATTRIBUTES: ProgramPropertyARB read _ACTIVE_ATTRIBUTES;
public static property ACTIVE_ATTRIBUTE_MAX_LENGTH: ProgramPropertyARB read _ACTIVE_ATTRIBUTE_MAX_LENGTH;
public static property TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: ProgramPropertyARB read _TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH;
public static property TRANSFORM_FEEDBACK_BUFFER_MODE: ProgramPropertyARB read _TRANSFORM_FEEDBACK_BUFFER_MODE;
public static property TRANSFORM_FEEDBACK_VARYINGS: ProgramPropertyARB read _TRANSFORM_FEEDBACK_VARYINGS;
public static property ACTIVE_ATOMIC_COUNTER_BUFFERS: ProgramPropertyARB read _ACTIVE_ATOMIC_COUNTER_BUFFERS;
public function ToString: string; override;
begin
if self.val = UInt32($8267) then Result := 'COMPUTE_WORK_GROUP_SIZE' else
if self.val = UInt32($8741) then Result := 'PROGRAM_BINARY_LENGTH' else
if self.val = UInt32($8916) then Result := 'GEOMETRY_VERTICES_OUT' else
if self.val = UInt32($8917) then Result := 'GEOMETRY_INPUT_TYPE' else
if self.val = UInt32($8918) then Result := 'GEOMETRY_OUTPUT_TYPE' else
if self.val = UInt32($8A35) then Result := 'ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH' else
if self.val = UInt32($8A36) then Result := 'ACTIVE_UNIFORM_BLOCKS' else
if self.val = UInt32($8B80) then Result := 'DELETE_STATUS' else
if self.val = UInt32($8B82) then Result := 'LINK_STATUS' else
if self.val = UInt32($8B83) then Result := 'VALIDATE_STATUS' else
if self.val = UInt32($8B84) then Result := 'INFO_LOG_LENGTH' else
if self.val = UInt32($8B85) then Result := 'ATTACHED_SHADERS' else
if self.val = UInt32($8B86) then Result := 'ACTIVE_UNIFORMS' else
if self.val = UInt32($8B87) then Result := 'ACTIVE_UNIFORM_MAX_LENGTH' else
if self.val = UInt32($8B89) then Result := 'ACTIVE_ATTRIBUTES' else
if self.val = UInt32($8B8A) then Result := 'ACTIVE_ATTRIBUTE_MAX_LENGTH' else
if self.val = UInt32($8C76) then Result := 'TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH' else
if self.val = UInt32($8C7F) then Result := 'TRANSFORM_FEEDBACK_BUFFER_MODE' else
if self.val = UInt32($8C83) then Result := 'TRANSFORM_FEEDBACK_VARYINGS' else
if self.val = UInt32($92D9) then Result := 'ACTIVE_ATOMIC_COUNTER_BUFFERS' else
Result := self.val.ToString;
end;
end;
VertexAttribPointerPropertyARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_ATTRIB_ARRAY_POINTER := new VertexAttribPointerPropertyARB($8645);
private static _VERTEX_ATTRIB_ARRAY_POINTER_ARB := new VertexAttribPointerPropertyARB($8645);
public static property VERTEX_ATTRIB_ARRAY_POINTER: VertexAttribPointerPropertyARB read _VERTEX_ATTRIB_ARRAY_POINTER;
public static property VERTEX_ATTRIB_ARRAY_POINTER_ARB: VertexAttribPointerPropertyARB read _VERTEX_ATTRIB_ARRAY_POINTER_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($8645) then Result := 'VERTEX_ATTRIB_ARRAY_POINTER' else
if self.val = UInt32($8645) then Result := 'VERTEX_ATTRIB_ARRAY_POINTER_ARB' else
Result := self.val.ToString;
end;
end;
VertexAttribPropertyARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_ATTRIB_BINDING := new VertexAttribPropertyARB($82D4);
private static _VERTEX_ATTRIB_RELATIVE_OFFSET := new VertexAttribPropertyARB($82D5);
private static _VERTEX_ATTRIB_ARRAY_ENABLED := new VertexAttribPropertyARB($8622);
private static _VERTEX_ATTRIB_ARRAY_SIZE := new VertexAttribPropertyARB($8623);
private static _VERTEX_ATTRIB_ARRAY_STRIDE := new VertexAttribPropertyARB($8624);
private static _VERTEX_ATTRIB_ARRAY_TYPE := new VertexAttribPropertyARB($8625);
private static _CURRENT_VERTEX_ATTRIB := new VertexAttribPropertyARB($8626);
private static _VERTEX_ATTRIB_ARRAY_LONG := new VertexAttribPropertyARB($874E);
private static _VERTEX_ATTRIB_ARRAY_NORMALIZED := new VertexAttribPropertyARB($886A);
private static _VERTEX_ATTRIB_ARRAY_BUFFER_BINDING := new VertexAttribPropertyARB($889F);
private static _VERTEX_ATTRIB_ARRAY_INTEGER := new VertexAttribPropertyARB($88FD);
private static _VERTEX_ATTRIB_ARRAY_INTEGER_EXT := new VertexAttribPropertyARB($88FD);
private static _VERTEX_ATTRIB_ARRAY_DIVISOR := new VertexAttribPropertyARB($88FE);
public static property VERTEX_ATTRIB_BINDING: VertexAttribPropertyARB read _VERTEX_ATTRIB_BINDING;
public static property VERTEX_ATTRIB_RELATIVE_OFFSET: VertexAttribPropertyARB read _VERTEX_ATTRIB_RELATIVE_OFFSET;
public static property VERTEX_ATTRIB_ARRAY_ENABLED: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_ENABLED;
public static property VERTEX_ATTRIB_ARRAY_SIZE: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_SIZE;
public static property VERTEX_ATTRIB_ARRAY_STRIDE: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_STRIDE;
public static property VERTEX_ATTRIB_ARRAY_TYPE: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_TYPE;
public static property CURRENT_VERTEX_ATTRIB: VertexAttribPropertyARB read _CURRENT_VERTEX_ATTRIB;
public static property VERTEX_ATTRIB_ARRAY_LONG: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_LONG;
public static property VERTEX_ATTRIB_ARRAY_NORMALIZED: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_NORMALIZED;
public static property VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_BUFFER_BINDING;
public static property VERTEX_ATTRIB_ARRAY_INTEGER: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_INTEGER;
public static property VERTEX_ATTRIB_ARRAY_INTEGER_EXT: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_INTEGER_EXT;
public static property VERTEX_ATTRIB_ARRAY_DIVISOR: VertexAttribPropertyARB read _VERTEX_ATTRIB_ARRAY_DIVISOR;
public function ToString: string; override;
begin
if self.val = UInt32($82D4) then Result := 'VERTEX_ATTRIB_BINDING' else
if self.val = UInt32($82D5) then Result := 'VERTEX_ATTRIB_RELATIVE_OFFSET' else
if self.val = UInt32($8622) then Result := 'VERTEX_ATTRIB_ARRAY_ENABLED' else
if self.val = UInt32($8623) then Result := 'VERTEX_ATTRIB_ARRAY_SIZE' else
if self.val = UInt32($8624) then Result := 'VERTEX_ATTRIB_ARRAY_STRIDE' else
if self.val = UInt32($8625) then Result := 'VERTEX_ATTRIB_ARRAY_TYPE' else
if self.val = UInt32($8626) then Result := 'CURRENT_VERTEX_ATTRIB' else
if self.val = UInt32($874E) then Result := 'VERTEX_ATTRIB_ARRAY_LONG' else
if self.val = UInt32($886A) then Result := 'VERTEX_ATTRIB_ARRAY_NORMALIZED' else
if self.val = UInt32($889F) then Result := 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING' else
if self.val = UInt32($88FD) then Result := 'VERTEX_ATTRIB_ARRAY_INTEGER' else
if self.val = UInt32($88FD) then Result := 'VERTEX_ATTRIB_ARRAY_INTEGER_EXT' else
if self.val = UInt32($88FE) then Result := 'VERTEX_ATTRIB_ARRAY_DIVISOR' else
Result := self.val.ToString;
end;
end;
WeightPointerTypeARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new WeightPointerTypeARB($1400);
private static _UNSIGNED_BYTE := new WeightPointerTypeARB($1401);
private static _SHORT := new WeightPointerTypeARB($1402);
private static _UNSIGNED_SHORT := new WeightPointerTypeARB($1403);
private static _INT := new WeightPointerTypeARB($1404);
private static _UNSIGNED_INT := new WeightPointerTypeARB($1405);
private static _FLOAT := new WeightPointerTypeARB($1406);
private static _DOUBLE := new WeightPointerTypeARB($140A);
public static property BYTE: WeightPointerTypeARB read _BYTE;
public static property UNSIGNED_BYTE: WeightPointerTypeARB read _UNSIGNED_BYTE;
public static property SHORT: WeightPointerTypeARB read _SHORT;
public static property UNSIGNED_SHORT: WeightPointerTypeARB read _UNSIGNED_SHORT;
public static property INT: WeightPointerTypeARB read _INT;
public static property UNSIGNED_INT: WeightPointerTypeARB read _UNSIGNED_INT;
public static property FLOAT: WeightPointerTypeARB read _FLOAT;
public static property DOUBLE: WeightPointerTypeARB read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
{$endregion ARB}
{$region EXT}
BinormalPointerTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new BinormalPointerTypeEXT($1400);
private static _SHORT := new BinormalPointerTypeEXT($1402);
private static _INT := new BinormalPointerTypeEXT($1404);
private static _FLOAT := new BinormalPointerTypeEXT($1406);
private static _DOUBLE := new BinormalPointerTypeEXT($140A);
private static _DOUBLE_EXT := new BinormalPointerTypeEXT($140A);
public static property BYTE: BinormalPointerTypeEXT read _BYTE;
public static property SHORT: BinormalPointerTypeEXT read _SHORT;
public static property INT: BinormalPointerTypeEXT read _INT;
public static property FLOAT: BinormalPointerTypeEXT read _FLOAT;
public static property DOUBLE: BinormalPointerTypeEXT read _DOUBLE;
public static property DOUBLE_EXT: BinormalPointerTypeEXT read _DOUBLE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($140A) then Result := 'DOUBLE_EXT' else
Result := self.val.ToString;
end;
end;
BlendEquationModeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FUNC_ADD := new BlendEquationModeEXT($8006);
private static _FUNC_ADD_EXT := new BlendEquationModeEXT($8006);
private static _MIN := new BlendEquationModeEXT($8007);
private static _MIN_EXT := new BlendEquationModeEXT($8007);
private static _MAX := new BlendEquationModeEXT($8008);
private static _MAX_EXT := new BlendEquationModeEXT($8008);
private static _FUNC_SUBTRACT := new BlendEquationModeEXT($800A);
private static _FUNC_SUBTRACT_EXT := new BlendEquationModeEXT($800A);
private static _FUNC_REVERSE_SUBTRACT := new BlendEquationModeEXT($800B);
private static _FUNC_REVERSE_SUBTRACT_EXT := new BlendEquationModeEXT($800B);
private static _ALPHA_MIN_SGIX := new BlendEquationModeEXT($8320);
private static _ALPHA_MAX_SGIX := new BlendEquationModeEXT($8321);
public static property FUNC_ADD: BlendEquationModeEXT read _FUNC_ADD;
public static property FUNC_ADD_EXT: BlendEquationModeEXT read _FUNC_ADD_EXT;
public static property MIN: BlendEquationModeEXT read _MIN;
public static property MIN_EXT: BlendEquationModeEXT read _MIN_EXT;
public static property MAX: BlendEquationModeEXT read _MAX;
public static property MAX_EXT: BlendEquationModeEXT read _MAX_EXT;
public static property FUNC_SUBTRACT: BlendEquationModeEXT read _FUNC_SUBTRACT;
public static property FUNC_SUBTRACT_EXT: BlendEquationModeEXT read _FUNC_SUBTRACT_EXT;
public static property FUNC_REVERSE_SUBTRACT: BlendEquationModeEXT read _FUNC_REVERSE_SUBTRACT;
public static property FUNC_REVERSE_SUBTRACT_EXT: BlendEquationModeEXT read _FUNC_REVERSE_SUBTRACT_EXT;
public static property ALPHA_MIN_SGIX: BlendEquationModeEXT read _ALPHA_MIN_SGIX;
public static property ALPHA_MAX_SGIX: BlendEquationModeEXT read _ALPHA_MAX_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8006) then Result := 'FUNC_ADD' else
if self.val = UInt32($8006) then Result := 'FUNC_ADD_EXT' else
if self.val = UInt32($8007) then Result := 'MIN' else
if self.val = UInt32($8007) then Result := 'MIN_EXT' else
if self.val = UInt32($8008) then Result := 'MAX' else
if self.val = UInt32($8008) then Result := 'MAX_EXT' else
if self.val = UInt32($800A) then Result := 'FUNC_SUBTRACT' else
if self.val = UInt32($800A) then Result := 'FUNC_SUBTRACT_EXT' else
if self.val = UInt32($800B) then Result := 'FUNC_REVERSE_SUBTRACT' else
if self.val = UInt32($800B) then Result := 'FUNC_REVERSE_SUBTRACT_EXT' else
if self.val = UInt32($8320) then Result := 'ALPHA_MIN_SGIX' else
if self.val = UInt32($8321) then Result := 'ALPHA_MAX_SGIX' else
Result := self.val.ToString;
end;
end;
ConvolutionParameterEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CONVOLUTION_BORDER_MODE := new ConvolutionParameterEXT($8013);
private static _CONVOLUTION_BORDER_MODE_EXT := new ConvolutionParameterEXT($8013);
private static _CONVOLUTION_FILTER_SCALE := new ConvolutionParameterEXT($8014);
private static _CONVOLUTION_FILTER_SCALE_EXT := new ConvolutionParameterEXT($8014);
private static _CONVOLUTION_FILTER_BIAS := new ConvolutionParameterEXT($8015);
private static _CONVOLUTION_FILTER_BIAS_EXT := new ConvolutionParameterEXT($8015);
public static property CONVOLUTION_BORDER_MODE: ConvolutionParameterEXT read _CONVOLUTION_BORDER_MODE;
public static property CONVOLUTION_BORDER_MODE_EXT: ConvolutionParameterEXT read _CONVOLUTION_BORDER_MODE_EXT;
public static property CONVOLUTION_FILTER_SCALE: ConvolutionParameterEXT read _CONVOLUTION_FILTER_SCALE;
public static property CONVOLUTION_FILTER_SCALE_EXT: ConvolutionParameterEXT read _CONVOLUTION_FILTER_SCALE_EXT;
public static property CONVOLUTION_FILTER_BIAS: ConvolutionParameterEXT read _CONVOLUTION_FILTER_BIAS;
public static property CONVOLUTION_FILTER_BIAS_EXT: ConvolutionParameterEXT read _CONVOLUTION_FILTER_BIAS_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8013) then Result := 'CONVOLUTION_BORDER_MODE' else
if self.val = UInt32($8013) then Result := 'CONVOLUTION_BORDER_MODE_EXT' else
if self.val = UInt32($8014) then Result := 'CONVOLUTION_FILTER_SCALE' else
if self.val = UInt32($8014) then Result := 'CONVOLUTION_FILTER_SCALE_EXT' else
if self.val = UInt32($8015) then Result := 'CONVOLUTION_FILTER_BIAS' else
if self.val = UInt32($8015) then Result := 'CONVOLUTION_FILTER_BIAS_EXT' else
Result := self.val.ToString;
end;
end;
ConvolutionTargetEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CONVOLUTION_1D := new ConvolutionTargetEXT($8010);
private static _CONVOLUTION_1D_EXT := new ConvolutionTargetEXT($8010);
private static _CONVOLUTION_2D := new ConvolutionTargetEXT($8011);
private static _CONVOLUTION_2D_EXT := new ConvolutionTargetEXT($8011);
public static property CONVOLUTION_1D: ConvolutionTargetEXT read _CONVOLUTION_1D;
public static property CONVOLUTION_1D_EXT: ConvolutionTargetEXT read _CONVOLUTION_1D_EXT;
public static property CONVOLUTION_2D: ConvolutionTargetEXT read _CONVOLUTION_2D;
public static property CONVOLUTION_2D_EXT: ConvolutionTargetEXT read _CONVOLUTION_2D_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8010) then Result := 'CONVOLUTION_1D' else
if self.val = UInt32($8010) then Result := 'CONVOLUTION_1D_EXT' else
if self.val = UInt32($8011) then Result := 'CONVOLUTION_2D' else
if self.val = UInt32($8011) then Result := 'CONVOLUTION_2D_EXT' else
Result := self.val.ToString;
end;
end;
CullParameterEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CULL_VERTEX_EYE_POSITION_EXT := new CullParameterEXT($81AB);
private static _CULL_VERTEX_OBJECT_POSITION_EXT := new CullParameterEXT($81AC);
public static property CULL_VERTEX_EYE_POSITION_EXT: CullParameterEXT read _CULL_VERTEX_EYE_POSITION_EXT;
public static property CULL_VERTEX_OBJECT_POSITION_EXT: CullParameterEXT read _CULL_VERTEX_OBJECT_POSITION_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($81AB) then Result := 'CULL_VERTEX_EYE_POSITION_EXT' else
if self.val = UInt32($81AC) then Result := 'CULL_VERTEX_OBJECT_POSITION_EXT' else
Result := self.val.ToString;
end;
end;
DataTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SCALAR_EXT := new DataTypeEXT($87BE);
private static _VECTOR_EXT := new DataTypeEXT($87BF);
private static _MATRIX_EXT := new DataTypeEXT($87C0);
public static property SCALAR_EXT: DataTypeEXT read _SCALAR_EXT;
public static property VECTOR_EXT: DataTypeEXT read _VECTOR_EXT;
public static property MATRIX_EXT: DataTypeEXT read _MATRIX_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87BE) then Result := 'SCALAR_EXT' else
if self.val = UInt32($87BF) then Result := 'VECTOR_EXT' else
if self.val = UInt32($87C0) then Result := 'MATRIX_EXT' else
Result := self.val.ToString;
end;
end;
FogPointerTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLOAT := new FogPointerTypeEXT($1406);
private static _DOUBLE := new FogPointerTypeEXT($140A);
public static property FLOAT: FogPointerTypeEXT read _FLOAT;
public static property DOUBLE: FogPointerTypeEXT read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
GetHistogramParameterPNameEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _HISTOGRAM_WIDTH := new GetHistogramParameterPNameEXT($8026);
private static _HISTOGRAM_WIDTH_EXT := new GetHistogramParameterPNameEXT($8026);
private static _HISTOGRAM_FORMAT := new GetHistogramParameterPNameEXT($8027);
private static _HISTOGRAM_FORMAT_EXT := new GetHistogramParameterPNameEXT($8027);
private static _HISTOGRAM_RED_SIZE := new GetHistogramParameterPNameEXT($8028);
private static _HISTOGRAM_RED_SIZE_EXT := new GetHistogramParameterPNameEXT($8028);
private static _HISTOGRAM_GREEN_SIZE := new GetHistogramParameterPNameEXT($8029);
private static _HISTOGRAM_GREEN_SIZE_EXT := new GetHistogramParameterPNameEXT($8029);
private static _HISTOGRAM_BLUE_SIZE := new GetHistogramParameterPNameEXT($802A);
private static _HISTOGRAM_BLUE_SIZE_EXT := new GetHistogramParameterPNameEXT($802A);
private static _HISTOGRAM_ALPHA_SIZE := new GetHistogramParameterPNameEXT($802B);
private static _HISTOGRAM_ALPHA_SIZE_EXT := new GetHistogramParameterPNameEXT($802B);
private static _HISTOGRAM_LUMINANCE_SIZE := new GetHistogramParameterPNameEXT($802C);
private static _HISTOGRAM_LUMINANCE_SIZE_EXT := new GetHistogramParameterPNameEXT($802C);
private static _HISTOGRAM_SINK := new GetHistogramParameterPNameEXT($802D);
private static _HISTOGRAM_SINK_EXT := new GetHistogramParameterPNameEXT($802D);
public static property HISTOGRAM_WIDTH: GetHistogramParameterPNameEXT read _HISTOGRAM_WIDTH;
public static property HISTOGRAM_WIDTH_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_WIDTH_EXT;
public static property HISTOGRAM_FORMAT: GetHistogramParameterPNameEXT read _HISTOGRAM_FORMAT;
public static property HISTOGRAM_FORMAT_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_FORMAT_EXT;
public static property HISTOGRAM_RED_SIZE: GetHistogramParameterPNameEXT read _HISTOGRAM_RED_SIZE;
public static property HISTOGRAM_RED_SIZE_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_RED_SIZE_EXT;
public static property HISTOGRAM_GREEN_SIZE: GetHistogramParameterPNameEXT read _HISTOGRAM_GREEN_SIZE;
public static property HISTOGRAM_GREEN_SIZE_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_GREEN_SIZE_EXT;
public static property HISTOGRAM_BLUE_SIZE: GetHistogramParameterPNameEXT read _HISTOGRAM_BLUE_SIZE;
public static property HISTOGRAM_BLUE_SIZE_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_BLUE_SIZE_EXT;
public static property HISTOGRAM_ALPHA_SIZE: GetHistogramParameterPNameEXT read _HISTOGRAM_ALPHA_SIZE;
public static property HISTOGRAM_ALPHA_SIZE_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_ALPHA_SIZE_EXT;
public static property HISTOGRAM_LUMINANCE_SIZE: GetHistogramParameterPNameEXT read _HISTOGRAM_LUMINANCE_SIZE;
public static property HISTOGRAM_LUMINANCE_SIZE_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_LUMINANCE_SIZE_EXT;
public static property HISTOGRAM_SINK: GetHistogramParameterPNameEXT read _HISTOGRAM_SINK;
public static property HISTOGRAM_SINK_EXT: GetHistogramParameterPNameEXT read _HISTOGRAM_SINK_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8026) then Result := 'HISTOGRAM_WIDTH' else
if self.val = UInt32($8026) then Result := 'HISTOGRAM_WIDTH_EXT' else
if self.val = UInt32($8027) then Result := 'HISTOGRAM_FORMAT' else
if self.val = UInt32($8027) then Result := 'HISTOGRAM_FORMAT_EXT' else
if self.val = UInt32($8028) then Result := 'HISTOGRAM_RED_SIZE' else
if self.val = UInt32($8028) then Result := 'HISTOGRAM_RED_SIZE_EXT' else
if self.val = UInt32($8029) then Result := 'HISTOGRAM_GREEN_SIZE' else
if self.val = UInt32($8029) then Result := 'HISTOGRAM_GREEN_SIZE_EXT' else
if self.val = UInt32($802A) then Result := 'HISTOGRAM_BLUE_SIZE' else
if self.val = UInt32($802A) then Result := 'HISTOGRAM_BLUE_SIZE_EXT' else
if self.val = UInt32($802B) then Result := 'HISTOGRAM_ALPHA_SIZE' else
if self.val = UInt32($802B) then Result := 'HISTOGRAM_ALPHA_SIZE_EXT' else
if self.val = UInt32($802C) then Result := 'HISTOGRAM_LUMINANCE_SIZE' else
if self.val = UInt32($802C) then Result := 'HISTOGRAM_LUMINANCE_SIZE_EXT' else
if self.val = UInt32($802D) then Result := 'HISTOGRAM_SINK' else
if self.val = UInt32($802D) then Result := 'HISTOGRAM_SINK_EXT' else
Result := self.val.ToString;
end;
end;
GetMinmaxParameterPNameEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MINMAX_FORMAT := new GetMinmaxParameterPNameEXT($802F);
private static _MINMAX_FORMAT_EXT := new GetMinmaxParameterPNameEXT($802F);
private static _MINMAX_SINK := new GetMinmaxParameterPNameEXT($8030);
private static _MINMAX_SINK_EXT := new GetMinmaxParameterPNameEXT($8030);
public static property MINMAX_FORMAT: GetMinmaxParameterPNameEXT read _MINMAX_FORMAT;
public static property MINMAX_FORMAT_EXT: GetMinmaxParameterPNameEXT read _MINMAX_FORMAT_EXT;
public static property MINMAX_SINK: GetMinmaxParameterPNameEXT read _MINMAX_SINK;
public static property MINMAX_SINK_EXT: GetMinmaxParameterPNameEXT read _MINMAX_SINK_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($802F) then Result := 'MINMAX_FORMAT' else
if self.val = UInt32($802F) then Result := 'MINMAX_FORMAT_EXT' else
if self.val = UInt32($8030) then Result := 'MINMAX_SINK' else
if self.val = UInt32($8030) then Result := 'MINMAX_SINK_EXT' else
Result := self.val.ToString;
end;
end;
GetVariantValueEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VARIANT_VALUE_EXT := new GetVariantValueEXT($87E4);
private static _VARIANT_DATATYPE_EXT := new GetVariantValueEXT($87E5);
private static _VARIANT_ARRAY_STRIDE_EXT := new GetVariantValueEXT($87E6);
private static _VARIANT_ARRAY_TYPE_EXT := new GetVariantValueEXT($87E7);
public static property VARIANT_VALUE_EXT: GetVariantValueEXT read _VARIANT_VALUE_EXT;
public static property VARIANT_DATATYPE_EXT: GetVariantValueEXT read _VARIANT_DATATYPE_EXT;
public static property VARIANT_ARRAY_STRIDE_EXT: GetVariantValueEXT read _VARIANT_ARRAY_STRIDE_EXT;
public static property VARIANT_ARRAY_TYPE_EXT: GetVariantValueEXT read _VARIANT_ARRAY_TYPE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87E4) then Result := 'VARIANT_VALUE_EXT' else
if self.val = UInt32($87E5) then Result := 'VARIANT_DATATYPE_EXT' else
if self.val = UInt32($87E6) then Result := 'VARIANT_ARRAY_STRIDE_EXT' else
if self.val = UInt32($87E7) then Result := 'VARIANT_ARRAY_TYPE_EXT' else
Result := self.val.ToString;
end;
end;
HistogramTargetEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _HISTOGRAM := new HistogramTargetEXT($8024);
private static _HISTOGRAM_EXT := new HistogramTargetEXT($8024);
private static _PROXY_HISTOGRAM := new HistogramTargetEXT($8025);
private static _PROXY_HISTOGRAM_EXT := new HistogramTargetEXT($8025);
public static property HISTOGRAM: HistogramTargetEXT read _HISTOGRAM;
public static property HISTOGRAM_EXT: HistogramTargetEXT read _HISTOGRAM_EXT;
public static property PROXY_HISTOGRAM: HistogramTargetEXT read _PROXY_HISTOGRAM;
public static property PROXY_HISTOGRAM_EXT: HistogramTargetEXT read _PROXY_HISTOGRAM_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8024) then Result := 'HISTOGRAM' else
if self.val = UInt32($8024) then Result := 'HISTOGRAM_EXT' else
if self.val = UInt32($8025) then Result := 'PROXY_HISTOGRAM' else
if self.val = UInt32($8025) then Result := 'PROXY_HISTOGRAM_EXT' else
Result := self.val.ToString;
end;
end;
IndexFunctionEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NEVER := new IndexFunctionEXT($0200);
private static _LESS := new IndexFunctionEXT($0201);
private static _EQUAL := new IndexFunctionEXT($0202);
private static _LEQUAL := new IndexFunctionEXT($0203);
private static _GREATER := new IndexFunctionEXT($0204);
private static _NOTEQUAL := new IndexFunctionEXT($0205);
private static _GEQUAL := new IndexFunctionEXT($0206);
private static _ALWAYS := new IndexFunctionEXT($0207);
public static property NEVER: IndexFunctionEXT read _NEVER;
public static property LESS: IndexFunctionEXT read _LESS;
public static property EQUAL: IndexFunctionEXT read _EQUAL;
public static property LEQUAL: IndexFunctionEXT read _LEQUAL;
public static property GREATER: IndexFunctionEXT read _GREATER;
public static property NOTEQUAL: IndexFunctionEXT read _NOTEQUAL;
public static property GEQUAL: IndexFunctionEXT read _GEQUAL;
public static property ALWAYS: IndexFunctionEXT read _ALWAYS;
public function ToString: string; override;
begin
if self.val = UInt32($0200) then Result := 'NEVER' else
if self.val = UInt32($0201) then Result := 'LESS' else
if self.val = UInt32($0202) then Result := 'EQUAL' else
if self.val = UInt32($0203) then Result := 'LEQUAL' else
if self.val = UInt32($0204) then Result := 'GREATER' else
if self.val = UInt32($0205) then Result := 'NOTEQUAL' else
if self.val = UInt32($0206) then Result := 'GEQUAL' else
if self.val = UInt32($0207) then Result := 'ALWAYS' else
Result := self.val.ToString;
end;
end;
IndexMaterialParameterEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _INDEX_OFFSET := new IndexMaterialParameterEXT($0D13);
public static property INDEX_OFFSET: IndexMaterialParameterEXT read _INDEX_OFFSET;
public function ToString: string; override;
begin
if self.val = UInt32($0D13) then Result := 'INDEX_OFFSET' else
Result := self.val.ToString;
end;
end;
LightTextureModeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAGMENT_MATERIAL_EXT := new LightTextureModeEXT($8349);
private static _FRAGMENT_NORMAL_EXT := new LightTextureModeEXT($834A);
private static _FRAGMENT_COLOR_EXT := new LightTextureModeEXT($834C);
private static _FRAGMENT_DEPTH_EXT := new LightTextureModeEXT($8452);
public static property FRAGMENT_MATERIAL_EXT: LightTextureModeEXT read _FRAGMENT_MATERIAL_EXT;
public static property FRAGMENT_NORMAL_EXT: LightTextureModeEXT read _FRAGMENT_NORMAL_EXT;
public static property FRAGMENT_COLOR_EXT: LightTextureModeEXT read _FRAGMENT_COLOR_EXT;
public static property FRAGMENT_DEPTH_EXT: LightTextureModeEXT read _FRAGMENT_DEPTH_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8349) then Result := 'FRAGMENT_MATERIAL_EXT' else
if self.val = UInt32($834A) then Result := 'FRAGMENT_NORMAL_EXT' else
if self.val = UInt32($834C) then Result := 'FRAGMENT_COLOR_EXT' else
if self.val = UInt32($8452) then Result := 'FRAGMENT_DEPTH_EXT' else
Result := self.val.ToString;
end;
end;
LightTexturePNameEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ATTENUATION_EXT := new LightTexturePNameEXT($834D);
private static _SHADOW_ATTENUATION_EXT := new LightTexturePNameEXT($834E);
public static property ATTENUATION_EXT: LightTexturePNameEXT read _ATTENUATION_EXT;
public static property SHADOW_ATTENUATION_EXT: LightTexturePNameEXT read _SHADOW_ATTENUATION_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($834D) then Result := 'ATTENUATION_EXT' else
if self.val = UInt32($834E) then Result := 'SHADOW_ATTENUATION_EXT' else
Result := self.val.ToString;
end;
end;
MinmaxTargetEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MINMAX := new MinmaxTargetEXT($802E);
private static _MINMAX_EXT := new MinmaxTargetEXT($802E);
public static property MINMAX: MinmaxTargetEXT read _MINMAX;
public static property MINMAX_EXT: MinmaxTargetEXT read _MINMAX_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($802E) then Result := 'MINMAX' else
if self.val = UInt32($802E) then Result := 'MINMAX_EXT' else
Result := self.val.ToString;
end;
end;
ParameterRangeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NORMALIZED_RANGE_EXT := new ParameterRangeEXT($87E0);
private static _FULL_RANGE_EXT := new ParameterRangeEXT($87E1);
public static property NORMALIZED_RANGE_EXT: ParameterRangeEXT read _NORMALIZED_RANGE_EXT;
public static property FULL_RANGE_EXT: ParameterRangeEXT read _FULL_RANGE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87E0) then Result := 'NORMALIZED_RANGE_EXT' else
if self.val = UInt32($87E1) then Result := 'FULL_RANGE_EXT' else
Result := self.val.ToString;
end;
end;
PixelTransformPNameEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_MAG_FILTER_EXT := new PixelTransformPNameEXT($8331);
private static _PIXEL_MIN_FILTER_EXT := new PixelTransformPNameEXT($8332);
private static _PIXEL_CUBIC_WEIGHT_EXT := new PixelTransformPNameEXT($8333);
public static property PIXEL_MAG_FILTER_EXT: PixelTransformPNameEXT read _PIXEL_MAG_FILTER_EXT;
public static property PIXEL_MIN_FILTER_EXT: PixelTransformPNameEXT read _PIXEL_MIN_FILTER_EXT;
public static property PIXEL_CUBIC_WEIGHT_EXT: PixelTransformPNameEXT read _PIXEL_CUBIC_WEIGHT_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8331) then Result := 'PIXEL_MAG_FILTER_EXT' else
if self.val = UInt32($8332) then Result := 'PIXEL_MIN_FILTER_EXT' else
if self.val = UInt32($8333) then Result := 'PIXEL_CUBIC_WEIGHT_EXT' else
Result := self.val.ToString;
end;
end;
PixelTransformTargetEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_TRANSFORM_2D_EXT := new PixelTransformTargetEXT($8330);
public static property PIXEL_TRANSFORM_2D_EXT: PixelTransformTargetEXT read _PIXEL_TRANSFORM_2D_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8330) then Result := 'PIXEL_TRANSFORM_2D_EXT' else
Result := self.val.ToString;
end;
end;
SamplePatternEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _GL_1PASS_EXT := new SamplePatternEXT($80A1);
private static _GL_2PASS_0_EXT := new SamplePatternEXT($80A2);
private static _GL_2PASS_1_EXT := new SamplePatternEXT($80A3);
private static _GL_4PASS_0_EXT := new SamplePatternEXT($80A4);
private static _GL_4PASS_1_EXT := new SamplePatternEXT($80A5);
private static _GL_4PASS_2_EXT := new SamplePatternEXT($80A6);
private static _GL_4PASS_3_EXT := new SamplePatternEXT($80A7);
public static property GL_1PASS_EXT: SamplePatternEXT read _GL_1PASS_EXT;
public static property GL_2PASS_0_EXT: SamplePatternEXT read _GL_2PASS_0_EXT;
public static property GL_2PASS_1_EXT: SamplePatternEXT read _GL_2PASS_1_EXT;
public static property GL_4PASS_0_EXT: SamplePatternEXT read _GL_4PASS_0_EXT;
public static property GL_4PASS_1_EXT: SamplePatternEXT read _GL_4PASS_1_EXT;
public static property GL_4PASS_2_EXT: SamplePatternEXT read _GL_4PASS_2_EXT;
public static property GL_4PASS_3_EXT: SamplePatternEXT read _GL_4PASS_3_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($80A1) then Result := 'GL_1PASS_EXT' else
if self.val = UInt32($80A2) then Result := 'GL_2PASS_0_EXT' else
if self.val = UInt32($80A3) then Result := 'GL_2PASS_1_EXT' else
if self.val = UInt32($80A4) then Result := 'GL_4PASS_0_EXT' else
if self.val = UInt32($80A5) then Result := 'GL_4PASS_1_EXT' else
if self.val = UInt32($80A6) then Result := 'GL_4PASS_2_EXT' else
if self.val = UInt32($80A7) then Result := 'GL_4PASS_3_EXT' else
Result := self.val.ToString;
end;
end;
SeparableTargetEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SEPARABLE_2D := new SeparableTargetEXT($8012);
private static _SEPARABLE_2D_EXT := new SeparableTargetEXT($8012);
public static property SEPARABLE_2D: SeparableTargetEXT read _SEPARABLE_2D;
public static property SEPARABLE_2D_EXT: SeparableTargetEXT read _SEPARABLE_2D_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8012) then Result := 'SEPARABLE_2D' else
if self.val = UInt32($8012) then Result := 'SEPARABLE_2D_EXT' else
Result := self.val.ToString;
end;
end;
TangentPointerTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BYTE := new TangentPointerTypeEXT($1400);
private static _SHORT := new TangentPointerTypeEXT($1402);
private static _INT := new TangentPointerTypeEXT($1404);
private static _FLOAT := new TangentPointerTypeEXT($1406);
private static _DOUBLE := new TangentPointerTypeEXT($140A);
private static _DOUBLE_EXT := new TangentPointerTypeEXT($140A);
public static property BYTE: TangentPointerTypeEXT read _BYTE;
public static property SHORT: TangentPointerTypeEXT read _SHORT;
public static property INT: TangentPointerTypeEXT read _INT;
public static property FLOAT: TangentPointerTypeEXT read _FLOAT;
public static property DOUBLE: TangentPointerTypeEXT read _DOUBLE;
public static property DOUBLE_EXT: TangentPointerTypeEXT read _DOUBLE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($1400) then Result := 'BYTE' else
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
if self.val = UInt32($140A) then Result := 'DOUBLE_EXT' else
Result := self.val.ToString;
end;
end;
TextureNormalModeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PERTURB_EXT := new TextureNormalModeEXT($85AE);
public static property PERTURB_EXT: TextureNormalModeEXT read _PERTURB_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($85AE) then Result := 'PERTURB_EXT' else
Result := self.val.ToString;
end;
end;
VariantCapEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VARIANT_ARRAY_EXT := new VariantCapEXT($87E8);
public static property VARIANT_ARRAY_EXT: VariantCapEXT read _VARIANT_ARRAY_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87E8) then Result := 'VARIANT_ARRAY_EXT' else
Result := self.val.ToString;
end;
end;
VertexShaderCoordOutEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _X_EXT := new VertexShaderCoordOutEXT($87D5);
private static _Y_EXT := new VertexShaderCoordOutEXT($87D6);
private static _Z_EXT := new VertexShaderCoordOutEXT($87D7);
private static _W_EXT := new VertexShaderCoordOutEXT($87D8);
private static _NEGATIVE_X_EXT := new VertexShaderCoordOutEXT($87D9);
private static _NEGATIVE_Y_EXT := new VertexShaderCoordOutEXT($87DA);
private static _NEGATIVE_Z_EXT := new VertexShaderCoordOutEXT($87DB);
private static _NEGATIVE_W_EXT := new VertexShaderCoordOutEXT($87DC);
private static _ZERO_EXT := new VertexShaderCoordOutEXT($87DD);
private static _ONE_EXT := new VertexShaderCoordOutEXT($87DE);
private static _NEGATIVE_ONE_EXT := new VertexShaderCoordOutEXT($87DF);
public static property X_EXT: VertexShaderCoordOutEXT read _X_EXT;
public static property Y_EXT: VertexShaderCoordOutEXT read _Y_EXT;
public static property Z_EXT: VertexShaderCoordOutEXT read _Z_EXT;
public static property W_EXT: VertexShaderCoordOutEXT read _W_EXT;
public static property NEGATIVE_X_EXT: VertexShaderCoordOutEXT read _NEGATIVE_X_EXT;
public static property NEGATIVE_Y_EXT: VertexShaderCoordOutEXT read _NEGATIVE_Y_EXT;
public static property NEGATIVE_Z_EXT: VertexShaderCoordOutEXT read _NEGATIVE_Z_EXT;
public static property NEGATIVE_W_EXT: VertexShaderCoordOutEXT read _NEGATIVE_W_EXT;
public static property ZERO_EXT: VertexShaderCoordOutEXT read _ZERO_EXT;
public static property ONE_EXT: VertexShaderCoordOutEXT read _ONE_EXT;
public static property NEGATIVE_ONE_EXT: VertexShaderCoordOutEXT read _NEGATIVE_ONE_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87D5) then Result := 'X_EXT' else
if self.val = UInt32($87D6) then Result := 'Y_EXT' else
if self.val = UInt32($87D7) then Result := 'Z_EXT' else
if self.val = UInt32($87D8) then Result := 'W_EXT' else
if self.val = UInt32($87D9) then Result := 'NEGATIVE_X_EXT' else
if self.val = UInt32($87DA) then Result := 'NEGATIVE_Y_EXT' else
if self.val = UInt32($87DB) then Result := 'NEGATIVE_Z_EXT' else
if self.val = UInt32($87DC) then Result := 'NEGATIVE_W_EXT' else
if self.val = UInt32($87DD) then Result := 'ZERO_EXT' else
if self.val = UInt32($87DE) then Result := 'ONE_EXT' else
if self.val = UInt32($87DF) then Result := 'NEGATIVE_ONE_EXT' else
Result := self.val.ToString;
end;
end;
VertexShaderOpEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _OP_INDEX_EXT := new VertexShaderOpEXT($8782);
private static _OP_NEGATE_EXT := new VertexShaderOpEXT($8783);
private static _OP_DOT3_EXT := new VertexShaderOpEXT($8784);
private static _OP_DOT4_EXT := new VertexShaderOpEXT($8785);
private static _OP_MUL_EXT := new VertexShaderOpEXT($8786);
private static _OP_ADD_EXT := new VertexShaderOpEXT($8787);
private static _OP_MADD_EXT := new VertexShaderOpEXT($8788);
private static _OP_FRAC_EXT := new VertexShaderOpEXT($8789);
private static _OP_MAX_EXT := new VertexShaderOpEXT($878A);
private static _OP_MIN_EXT := new VertexShaderOpEXT($878B);
private static _OP_SET_GE_EXT := new VertexShaderOpEXT($878C);
private static _OP_SET_LT_EXT := new VertexShaderOpEXT($878D);
private static _OP_CLAMP_EXT := new VertexShaderOpEXT($878E);
private static _OP_FLOOR_EXT := new VertexShaderOpEXT($878F);
private static _OP_ROUND_EXT := new VertexShaderOpEXT($8790);
private static _OP_EXP_BASE_2_EXT := new VertexShaderOpEXT($8791);
private static _OP_LOG_BASE_2_EXT := new VertexShaderOpEXT($8792);
private static _OP_POWER_EXT := new VertexShaderOpEXT($8793);
private static _OP_RECIP_EXT := new VertexShaderOpEXT($8794);
private static _OP_RECIP_SQRT_EXT := new VertexShaderOpEXT($8795);
private static _OP_SUB_EXT := new VertexShaderOpEXT($8796);
private static _OP_CROSS_PRODUCT_EXT := new VertexShaderOpEXT($8797);
private static _OP_MULTIPLY_MATRIX_EXT := new VertexShaderOpEXT($8798);
private static _OP_MOV_EXT := new VertexShaderOpEXT($8799);
public static property OP_INDEX_EXT: VertexShaderOpEXT read _OP_INDEX_EXT;
public static property OP_NEGATE_EXT: VertexShaderOpEXT read _OP_NEGATE_EXT;
public static property OP_DOT3_EXT: VertexShaderOpEXT read _OP_DOT3_EXT;
public static property OP_DOT4_EXT: VertexShaderOpEXT read _OP_DOT4_EXT;
public static property OP_MUL_EXT: VertexShaderOpEXT read _OP_MUL_EXT;
public static property OP_ADD_EXT: VertexShaderOpEXT read _OP_ADD_EXT;
public static property OP_MADD_EXT: VertexShaderOpEXT read _OP_MADD_EXT;
public static property OP_FRAC_EXT: VertexShaderOpEXT read _OP_FRAC_EXT;
public static property OP_MAX_EXT: VertexShaderOpEXT read _OP_MAX_EXT;
public static property OP_MIN_EXT: VertexShaderOpEXT read _OP_MIN_EXT;
public static property OP_SET_GE_EXT: VertexShaderOpEXT read _OP_SET_GE_EXT;
public static property OP_SET_LT_EXT: VertexShaderOpEXT read _OP_SET_LT_EXT;
public static property OP_CLAMP_EXT: VertexShaderOpEXT read _OP_CLAMP_EXT;
public static property OP_FLOOR_EXT: VertexShaderOpEXT read _OP_FLOOR_EXT;
public static property OP_ROUND_EXT: VertexShaderOpEXT read _OP_ROUND_EXT;
public static property OP_EXP_BASE_2_EXT: VertexShaderOpEXT read _OP_EXP_BASE_2_EXT;
public static property OP_LOG_BASE_2_EXT: VertexShaderOpEXT read _OP_LOG_BASE_2_EXT;
public static property OP_POWER_EXT: VertexShaderOpEXT read _OP_POWER_EXT;
public static property OP_RECIP_EXT: VertexShaderOpEXT read _OP_RECIP_EXT;
public static property OP_RECIP_SQRT_EXT: VertexShaderOpEXT read _OP_RECIP_SQRT_EXT;
public static property OP_SUB_EXT: VertexShaderOpEXT read _OP_SUB_EXT;
public static property OP_CROSS_PRODUCT_EXT: VertexShaderOpEXT read _OP_CROSS_PRODUCT_EXT;
public static property OP_MULTIPLY_MATRIX_EXT: VertexShaderOpEXT read _OP_MULTIPLY_MATRIX_EXT;
public static property OP_MOV_EXT: VertexShaderOpEXT read _OP_MOV_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($8782) then Result := 'OP_INDEX_EXT' else
if self.val = UInt32($8783) then Result := 'OP_NEGATE_EXT' else
if self.val = UInt32($8784) then Result := 'OP_DOT3_EXT' else
if self.val = UInt32($8785) then Result := 'OP_DOT4_EXT' else
if self.val = UInt32($8786) then Result := 'OP_MUL_EXT' else
if self.val = UInt32($8787) then Result := 'OP_ADD_EXT' else
if self.val = UInt32($8788) then Result := 'OP_MADD_EXT' else
if self.val = UInt32($8789) then Result := 'OP_FRAC_EXT' else
if self.val = UInt32($878A) then Result := 'OP_MAX_EXT' else
if self.val = UInt32($878B) then Result := 'OP_MIN_EXT' else
if self.val = UInt32($878C) then Result := 'OP_SET_GE_EXT' else
if self.val = UInt32($878D) then Result := 'OP_SET_LT_EXT' else
if self.val = UInt32($878E) then Result := 'OP_CLAMP_EXT' else
if self.val = UInt32($878F) then Result := 'OP_FLOOR_EXT' else
if self.val = UInt32($8790) then Result := 'OP_ROUND_EXT' else
if self.val = UInt32($8791) then Result := 'OP_EXP_BASE_2_EXT' else
if self.val = UInt32($8792) then Result := 'OP_LOG_BASE_2_EXT' else
if self.val = UInt32($8793) then Result := 'OP_POWER_EXT' else
if self.val = UInt32($8794) then Result := 'OP_RECIP_EXT' else
if self.val = UInt32($8795) then Result := 'OP_RECIP_SQRT_EXT' else
if self.val = UInt32($8796) then Result := 'OP_SUB_EXT' else
if self.val = UInt32($8797) then Result := 'OP_CROSS_PRODUCT_EXT' else
if self.val = UInt32($8798) then Result := 'OP_MULTIPLY_MATRIX_EXT' else
if self.val = UInt32($8799) then Result := 'OP_MOV_EXT' else
Result := self.val.ToString;
end;
end;
VertexShaderParameterEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _CURRENT_VERTEX_EXT := new VertexShaderParameterEXT($87E2);
private static _MVP_MATRIX_EXT := new VertexShaderParameterEXT($87E3);
public static property CURRENT_VERTEX_EXT: VertexShaderParameterEXT read _CURRENT_VERTEX_EXT;
public static property MVP_MATRIX_EXT: VertexShaderParameterEXT read _MVP_MATRIX_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87E2) then Result := 'CURRENT_VERTEX_EXT' else
if self.val = UInt32($87E3) then Result := 'MVP_MATRIX_EXT' else
Result := self.val.ToString;
end;
end;
VertexShaderStorageTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VARIANT_EXT := new VertexShaderStorageTypeEXT($87C1);
private static _INVARIANT_EXT := new VertexShaderStorageTypeEXT($87C2);
private static _LOCAL_CONSTANT_EXT := new VertexShaderStorageTypeEXT($87C3);
private static _LOCAL_EXT := new VertexShaderStorageTypeEXT($87C4);
public static property VARIANT_EXT: VertexShaderStorageTypeEXT read _VARIANT_EXT;
public static property INVARIANT_EXT: VertexShaderStorageTypeEXT read _INVARIANT_EXT;
public static property LOCAL_CONSTANT_EXT: VertexShaderStorageTypeEXT read _LOCAL_CONSTANT_EXT;
public static property LOCAL_EXT: VertexShaderStorageTypeEXT read _LOCAL_EXT;
public function ToString: string; override;
begin
if self.val = UInt32($87C1) then Result := 'VARIANT_EXT' else
if self.val = UInt32($87C2) then Result := 'INVARIANT_EXT' else
if self.val = UInt32($87C3) then Result := 'LOCAL_CONSTANT_EXT' else
if self.val = UInt32($87C4) then Result := 'LOCAL_EXT' else
Result := self.val.ToString;
end;
end;
VertexShaderWriteMaskEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FALSE := new VertexShaderWriteMaskEXT($0000);
private static _TRUE := new VertexShaderWriteMaskEXT($0001);
public static property FALSE: VertexShaderWriteMaskEXT read _FALSE;
public static property TRUE: VertexShaderWriteMaskEXT read _TRUE;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'FALSE' else
if self.val = UInt32($0001) then Result := 'TRUE' else
Result := self.val.ToString;
end;
end;
VertexWeightPointerTypeEXT = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLOAT := new VertexWeightPointerTypeEXT($1406);
public static property FLOAT: VertexWeightPointerTypeEXT read _FLOAT;
public function ToString: string; override;
begin
if self.val = UInt32($1406) then Result := 'FLOAT' else
Result := self.val.ToString;
end;
end;
{$endregion EXT}
{$region AMD}
TextureStorageMaskAMD = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_STORAGE_SPARSE_BIT_AMD := new TextureStorageMaskAMD($0001);
public static property TEXTURE_STORAGE_SPARSE_BIT_AMD: TextureStorageMaskAMD read _TEXTURE_STORAGE_SPARSE_BIT_AMD;
public static function operator or(f1,f2: TextureStorageMaskAMD) := new TextureStorageMaskAMD(f1.val or f2.val);
public property HAS_FLAG_TEXTURE_STORAGE_SPARSE_BIT_AMD: boolean read self.val and $0001 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'TEXTURE_STORAGE_SPARSE_BIT_AMD+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
{$endregion AMD}
{$region APPLE}
ObjectTypeAPPLE = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DRAW_PIXELS_APPLE := new ObjectTypeAPPLE($8A0A);
private static _FENCE_APPLE := new ObjectTypeAPPLE($8A0B);
public static property DRAW_PIXELS_APPLE: ObjectTypeAPPLE read _DRAW_PIXELS_APPLE;
public static property FENCE_APPLE: ObjectTypeAPPLE read _FENCE_APPLE;
public function ToString: string; override;
begin
if self.val = UInt32($8A0A) then Result := 'DRAW_PIXELS_APPLE' else
if self.val = UInt32($8A0B) then Result := 'FENCE_APPLE' else
Result := self.val.ToString;
end;
end;
VertexArrayPNameAPPLE = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STORAGE_CLIENT_APPLE := new VertexArrayPNameAPPLE($85B4);
private static _STORAGE_CACHED_APPLE := new VertexArrayPNameAPPLE($85BE);
private static _STORAGE_SHARED_APPLE := new VertexArrayPNameAPPLE($85BF);
public static property STORAGE_CLIENT_APPLE: VertexArrayPNameAPPLE read _STORAGE_CLIENT_APPLE;
public static property STORAGE_CACHED_APPLE: VertexArrayPNameAPPLE read _STORAGE_CACHED_APPLE;
public static property STORAGE_SHARED_APPLE: VertexArrayPNameAPPLE read _STORAGE_SHARED_APPLE;
public function ToString: string; override;
begin
if self.val = UInt32($85B4) then Result := 'STORAGE_CLIENT_APPLE' else
if self.val = UInt32($85BE) then Result := 'STORAGE_CACHED_APPLE' else
if self.val = UInt32($85BF) then Result := 'STORAGE_SHARED_APPLE' else
Result := self.val.ToString;
end;
end;
{$endregion APPLE}
{$region ATI}
ArrayObjectPNameATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _OBJECT_BUFFER_SIZE_ATI := new ArrayObjectPNameATI($8764);
private static _OBJECT_BUFFER_USAGE_ATI := new ArrayObjectPNameATI($8765);
public static property OBJECT_BUFFER_SIZE_ATI: ArrayObjectPNameATI read _OBJECT_BUFFER_SIZE_ATI;
public static property OBJECT_BUFFER_USAGE_ATI: ArrayObjectPNameATI read _OBJECT_BUFFER_USAGE_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8764) then Result := 'OBJECT_BUFFER_SIZE_ATI' else
if self.val = UInt32($8765) then Result := 'OBJECT_BUFFER_USAGE_ATI' else
Result := self.val.ToString;
end;
end;
ArrayObjectUsageATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _STATIC_ATI := new ArrayObjectUsageATI($8760);
private static _DYNAMIC_ATI := new ArrayObjectUsageATI($8761);
public static property STATIC_ATI: ArrayObjectUsageATI read _STATIC_ATI;
public static property DYNAMIC_ATI: ArrayObjectUsageATI read _DYNAMIC_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8760) then Result := 'STATIC_ATI' else
if self.val = UInt32($8761) then Result := 'DYNAMIC_ATI' else
Result := self.val.ToString;
end;
end;
ElementPointerTypeATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_BYTE := new ElementPointerTypeATI($1401);
private static _UNSIGNED_SHORT := new ElementPointerTypeATI($1403);
private static _UNSIGNED_INT := new ElementPointerTypeATI($1405);
public static property UNSIGNED_BYTE: ElementPointerTypeATI read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: ElementPointerTypeATI read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: ElementPointerTypeATI read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
FragmentOpATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MOV_ATI := new FragmentOpATI($8961);
private static _ADD_ATI := new FragmentOpATI($8963);
private static _MUL_ATI := new FragmentOpATI($8964);
private static _SUB_ATI := new FragmentOpATI($8965);
private static _DOT3_ATI := new FragmentOpATI($8966);
private static _DOT4_ATI := new FragmentOpATI($8967);
private static _MAD_ATI := new FragmentOpATI($8968);
private static _LERP_ATI := new FragmentOpATI($8969);
private static _CND_ATI := new FragmentOpATI($896A);
private static _CND0_ATI := new FragmentOpATI($896B);
private static _DOT2_ADD_ATI := new FragmentOpATI($896C);
public static property MOV_ATI: FragmentOpATI read _MOV_ATI;
public static property ADD_ATI: FragmentOpATI read _ADD_ATI;
public static property MUL_ATI: FragmentOpATI read _MUL_ATI;
public static property SUB_ATI: FragmentOpATI read _SUB_ATI;
public static property DOT3_ATI: FragmentOpATI read _DOT3_ATI;
public static property DOT4_ATI: FragmentOpATI read _DOT4_ATI;
public static property MAD_ATI: FragmentOpATI read _MAD_ATI;
public static property LERP_ATI: FragmentOpATI read _LERP_ATI;
public static property CND_ATI: FragmentOpATI read _CND_ATI;
public static property CND0_ATI: FragmentOpATI read _CND0_ATI;
public static property DOT2_ADD_ATI: FragmentOpATI read _DOT2_ADD_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8961) then Result := 'MOV_ATI' else
if self.val = UInt32($8963) then Result := 'ADD_ATI' else
if self.val = UInt32($8964) then Result := 'MUL_ATI' else
if self.val = UInt32($8965) then Result := 'SUB_ATI' else
if self.val = UInt32($8966) then Result := 'DOT3_ATI' else
if self.val = UInt32($8967) then Result := 'DOT4_ATI' else
if self.val = UInt32($8968) then Result := 'MAD_ATI' else
if self.val = UInt32($8969) then Result := 'LERP_ATI' else
if self.val = UInt32($896A) then Result := 'CND_ATI' else
if self.val = UInt32($896B) then Result := 'CND0_ATI' else
if self.val = UInt32($896C) then Result := 'DOT2_ADD_ATI' else
Result := self.val.ToString;
end;
end;
GetTexBumpParameterATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BUMP_ROT_MATRIX_ATI := new GetTexBumpParameterATI($8775);
private static _BUMP_ROT_MATRIX_SIZE_ATI := new GetTexBumpParameterATI($8776);
private static _BUMP_NUM_TEX_UNITS_ATI := new GetTexBumpParameterATI($8777);
private static _BUMP_TEX_UNITS_ATI := new GetTexBumpParameterATI($8778);
public static property BUMP_ROT_MATRIX_ATI: GetTexBumpParameterATI read _BUMP_ROT_MATRIX_ATI;
public static property BUMP_ROT_MATRIX_SIZE_ATI: GetTexBumpParameterATI read _BUMP_ROT_MATRIX_SIZE_ATI;
public static property BUMP_NUM_TEX_UNITS_ATI: GetTexBumpParameterATI read _BUMP_NUM_TEX_UNITS_ATI;
public static property BUMP_TEX_UNITS_ATI: GetTexBumpParameterATI read _BUMP_TEX_UNITS_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8775) then Result := 'BUMP_ROT_MATRIX_ATI' else
if self.val = UInt32($8776) then Result := 'BUMP_ROT_MATRIX_SIZE_ATI' else
if self.val = UInt32($8777) then Result := 'BUMP_NUM_TEX_UNITS_ATI' else
if self.val = UInt32($8778) then Result := 'BUMP_TEX_UNITS_ATI' else
Result := self.val.ToString;
end;
end;
PNTrianglesPNameATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PN_TRIANGLES_POINT_MODE_ATI := new PNTrianglesPNameATI($87F2);
private static _PN_TRIANGLES_NORMAL_MODE_ATI := new PNTrianglesPNameATI($87F3);
private static _PN_TRIANGLES_TESSELATION_LEVEL_ATI := new PNTrianglesPNameATI($87F4);
public static property PN_TRIANGLES_POINT_MODE_ATI: PNTrianglesPNameATI read _PN_TRIANGLES_POINT_MODE_ATI;
public static property PN_TRIANGLES_NORMAL_MODE_ATI: PNTrianglesPNameATI read _PN_TRIANGLES_NORMAL_MODE_ATI;
public static property PN_TRIANGLES_TESSELATION_LEVEL_ATI: PNTrianglesPNameATI read _PN_TRIANGLES_TESSELATION_LEVEL_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($87F2) then Result := 'PN_TRIANGLES_POINT_MODE_ATI' else
if self.val = UInt32($87F3) then Result := 'PN_TRIANGLES_NORMAL_MODE_ATI' else
if self.val = UInt32($87F4) then Result := 'PN_TRIANGLES_TESSELATION_LEVEL_ATI' else
Result := self.val.ToString;
end;
end;
PreserveModeATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PRESERVE_ATI := new PreserveModeATI($8762);
private static _DISCARD_ATI := new PreserveModeATI($8763);
public static property PRESERVE_ATI: PreserveModeATI read _PRESERVE_ATI;
public static property DISCARD_ATI: PreserveModeATI read _DISCARD_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8762) then Result := 'PRESERVE_ATI' else
if self.val = UInt32($8763) then Result := 'DISCARD_ATI' else
Result := self.val.ToString;
end;
end;
SwizzleOpATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SWIZZLE_STR_ATI := new SwizzleOpATI($8976);
private static _SWIZZLE_STQ_ATI := new SwizzleOpATI($8977);
private static _SWIZZLE_STR_DR_ATI := new SwizzleOpATI($8978);
private static _SWIZZLE_STQ_DQ_ATI := new SwizzleOpATI($8979);
public static property SWIZZLE_STR_ATI: SwizzleOpATI read _SWIZZLE_STR_ATI;
public static property SWIZZLE_STQ_ATI: SwizzleOpATI read _SWIZZLE_STQ_ATI;
public static property SWIZZLE_STR_DR_ATI: SwizzleOpATI read _SWIZZLE_STR_DR_ATI;
public static property SWIZZLE_STQ_DQ_ATI: SwizzleOpATI read _SWIZZLE_STQ_DQ_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8976) then Result := 'SWIZZLE_STR_ATI' else
if self.val = UInt32($8977) then Result := 'SWIZZLE_STQ_ATI' else
if self.val = UInt32($8978) then Result := 'SWIZZLE_STR_DR_ATI' else
if self.val = UInt32($8979) then Result := 'SWIZZLE_STQ_DQ_ATI' else
Result := self.val.ToString;
end;
end;
TexBumpParameterATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BUMP_ROT_MATRIX_ATI := new TexBumpParameterATI($8775);
public static property BUMP_ROT_MATRIX_ATI: TexBumpParameterATI read _BUMP_ROT_MATRIX_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($8775) then Result := 'BUMP_ROT_MATRIX_ATI' else
Result := self.val.ToString;
end;
end;
VertexStreamATI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_STREAM0_ATI := new VertexStreamATI($876C);
private static _VERTEX_STREAM1_ATI := new VertexStreamATI($876D);
private static _VERTEX_STREAM2_ATI := new VertexStreamATI($876E);
private static _VERTEX_STREAM3_ATI := new VertexStreamATI($876F);
private static _VERTEX_STREAM4_ATI := new VertexStreamATI($8770);
private static _VERTEX_STREAM5_ATI := new VertexStreamATI($8771);
private static _VERTEX_STREAM6_ATI := new VertexStreamATI($8772);
private static _VERTEX_STREAM7_ATI := new VertexStreamATI($8773);
public static property VERTEX_STREAM0_ATI: VertexStreamATI read _VERTEX_STREAM0_ATI;
public static property VERTEX_STREAM1_ATI: VertexStreamATI read _VERTEX_STREAM1_ATI;
public static property VERTEX_STREAM2_ATI: VertexStreamATI read _VERTEX_STREAM2_ATI;
public static property VERTEX_STREAM3_ATI: VertexStreamATI read _VERTEX_STREAM3_ATI;
public static property VERTEX_STREAM4_ATI: VertexStreamATI read _VERTEX_STREAM4_ATI;
public static property VERTEX_STREAM5_ATI: VertexStreamATI read _VERTEX_STREAM5_ATI;
public static property VERTEX_STREAM6_ATI: VertexStreamATI read _VERTEX_STREAM6_ATI;
public static property VERTEX_STREAM7_ATI: VertexStreamATI read _VERTEX_STREAM7_ATI;
public function ToString: string; override;
begin
if self.val = UInt32($876C) then Result := 'VERTEX_STREAM0_ATI' else
if self.val = UInt32($876D) then Result := 'VERTEX_STREAM1_ATI' else
if self.val = UInt32($876E) then Result := 'VERTEX_STREAM2_ATI' else
if self.val = UInt32($876F) then Result := 'VERTEX_STREAM3_ATI' else
if self.val = UInt32($8770) then Result := 'VERTEX_STREAM4_ATI' else
if self.val = UInt32($8771) then Result := 'VERTEX_STREAM5_ATI' else
if self.val = UInt32($8772) then Result := 'VERTEX_STREAM6_ATI' else
if self.val = UInt32($8773) then Result := 'VERTEX_STREAM7_ATI' else
Result := self.val.ToString;
end;
end;
{$endregion ATI}
{$region GDI}
PixelDataTypeGDI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _RGBA := new PixelDataTypeGDI($0000);
private static _COLORINDEX := new PixelDataTypeGDI($0001);
public static property RGBA: PixelDataTypeGDI read _RGBA;
public static property COLORINDEX: PixelDataTypeGDI read _COLORINDEX;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'RGBA' else
if self.val = UInt32($0001) then Result := 'COLORINDEX' else
Result := self.val.ToString;
end;
end;
PixelFormatFlagsGDI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _DOUBLEBUFFER := new PixelFormatFlagsGDI($0001);
private static _STEREO := new PixelFormatFlagsGDI($0002);
private static _DRAW_TO_WINDOW := new PixelFormatFlagsGDI($0004);
private static _DRAW_TO_BITMAP := new PixelFormatFlagsGDI($0008);
private static _SUPPORT_GDI := new PixelFormatFlagsGDI($000A);
private static _SUPPORT_OPENGL := new PixelFormatFlagsGDI($0014);
private static _GENERIC_FORMAT := new PixelFormatFlagsGDI($0028);
private static _NEED_PALETTE := new PixelFormatFlagsGDI($0050);
private static _NEED_SYSTEM_PALETTE := new PixelFormatFlagsGDI($0064);
private static _SWAP_EXCHANGE := new PixelFormatFlagsGDI($00C8);
private static _SWAP_COPY := new PixelFormatFlagsGDI($0190);
private static _SWAP_LAYER_BUFFERS := new PixelFormatFlagsGDI($0320);
private static _GENERIC_ACCELERATED := new PixelFormatFlagsGDI($03E8);
private static _SUPPORT_DIRECTDRAW := new PixelFormatFlagsGDI($07D0);
private static _DEPTH_DONTCARE := new PixelFormatFlagsGDI($1312D00);
private static _DOUBLEBUFFER_DONTCARE := new PixelFormatFlagsGDI($2625A00);
private static _STEREO_DONTCARE := new PixelFormatFlagsGDI($4C4B400);
public static property DOUBLEBUFFER: PixelFormatFlagsGDI read _DOUBLEBUFFER;
public static property STEREO: PixelFormatFlagsGDI read _STEREO;
public static property DRAW_TO_WINDOW: PixelFormatFlagsGDI read _DRAW_TO_WINDOW;
public static property DRAW_TO_BITMAP: PixelFormatFlagsGDI read _DRAW_TO_BITMAP;
public static property SUPPORT_GDI: PixelFormatFlagsGDI read _SUPPORT_GDI;
public static property SUPPORT_OPENGL: PixelFormatFlagsGDI read _SUPPORT_OPENGL;
public static property GENERIC_FORMAT: PixelFormatFlagsGDI read _GENERIC_FORMAT;
public static property NEED_PALETTE: PixelFormatFlagsGDI read _NEED_PALETTE;
public static property NEED_SYSTEM_PALETTE: PixelFormatFlagsGDI read _NEED_SYSTEM_PALETTE;
public static property SWAP_EXCHANGE: PixelFormatFlagsGDI read _SWAP_EXCHANGE;
public static property SWAP_COPY: PixelFormatFlagsGDI read _SWAP_COPY;
public static property SWAP_LAYER_BUFFERS: PixelFormatFlagsGDI read _SWAP_LAYER_BUFFERS;
public static property GENERIC_ACCELERATED: PixelFormatFlagsGDI read _GENERIC_ACCELERATED;
public static property SUPPORT_DIRECTDRAW: PixelFormatFlagsGDI read _SUPPORT_DIRECTDRAW;
public static property DEPTH_DONTCARE: PixelFormatFlagsGDI read _DEPTH_DONTCARE;
public static property DOUBLEBUFFER_DONTCARE: PixelFormatFlagsGDI read _DOUBLEBUFFER_DONTCARE;
public static property STEREO_DONTCARE: PixelFormatFlagsGDI read _STEREO_DONTCARE;
public static function operator or(f1,f2: PixelFormatFlagsGDI) := new PixelFormatFlagsGDI(f1.val or f2.val);
public property HAS_FLAG_DOUBLEBUFFER: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_STEREO: boolean read self.val and $0002 <> 0;
public property HAS_FLAG_DRAW_TO_WINDOW: boolean read self.val and $0004 <> 0;
public property HAS_FLAG_DRAW_TO_BITMAP: boolean read self.val and $0008 <> 0;
public property HAS_FLAG_SUPPORT_GDI: boolean read self.val and $000A <> 0;
public property HAS_FLAG_SUPPORT_OPENGL: boolean read self.val and $0014 <> 0;
public property HAS_FLAG_GENERIC_FORMAT: boolean read self.val and $0028 <> 0;
public property HAS_FLAG_NEED_PALETTE: boolean read self.val and $0050 <> 0;
public property HAS_FLAG_NEED_SYSTEM_PALETTE: boolean read self.val and $0064 <> 0;
public property HAS_FLAG_SWAP_EXCHANGE: boolean read self.val and $00C8 <> 0;
public property HAS_FLAG_SWAP_COPY: boolean read self.val and $0190 <> 0;
public property HAS_FLAG_SWAP_LAYER_BUFFERS: boolean read self.val and $0320 <> 0;
public property HAS_FLAG_GENERIC_ACCELERATED: boolean read self.val and $03E8 <> 0;
public property HAS_FLAG_SUPPORT_DIRECTDRAW: boolean read self.val and $07D0 <> 0;
public property HAS_FLAG_DEPTH_DONTCARE: boolean read self.val and $1312D00 <> 0;
public property HAS_FLAG_DOUBLEBUFFER_DONTCARE: boolean read self.val and $2625A00 <> 0;
public property HAS_FLAG_STEREO_DONTCARE: boolean read self.val and $4C4B400 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'DOUBLEBUFFER+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'STEREO+';
if self.val and UInt32($0004) = UInt32($0004) then res += 'DRAW_TO_WINDOW+';
if self.val and UInt32($0008) = UInt32($0008) then res += 'DRAW_TO_BITMAP+';
if self.val and UInt32($000A) = UInt32($000A) then res += 'SUPPORT_GDI+';
if self.val and UInt32($0014) = UInt32($0014) then res += 'SUPPORT_OPENGL+';
if self.val and UInt32($0028) = UInt32($0028) then res += 'GENERIC_FORMAT+';
if self.val and UInt32($0050) = UInt32($0050) then res += 'NEED_PALETTE+';
if self.val and UInt32($0064) = UInt32($0064) then res += 'NEED_SYSTEM_PALETTE+';
if self.val and UInt32($00C8) = UInt32($00C8) then res += 'SWAP_EXCHANGE+';
if self.val and UInt32($0190) = UInt32($0190) then res += 'SWAP_COPY+';
if self.val and UInt32($0320) = UInt32($0320) then res += 'SWAP_LAYER_BUFFERS+';
if self.val and UInt32($03E8) = UInt32($03E8) then res += 'GENERIC_ACCELERATED+';
if self.val and UInt32($07D0) = UInt32($07D0) then res += 'SUPPORT_DIRECTDRAW+';
if self.val and UInt32($1312D00) = UInt32($1312D00) then res += 'DEPTH_DONTCARE+';
if self.val and UInt32($2625A00) = UInt32($2625A00) then res += 'DOUBLEBUFFER_DONTCARE+';
if self.val and UInt32($4C4B400) = UInt32($4C4B400) then res += 'STEREO_DONTCARE+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
{$endregion GDI}
{$region HP}
ImageTransformPNameHP = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _IMAGE_SCALE_X_HP := new ImageTransformPNameHP($8155);
private static _IMAGE_SCALE_Y_HP := new ImageTransformPNameHP($8156);
private static _IMAGE_TRANSLATE_X_HP := new ImageTransformPNameHP($8157);
private static _IMAGE_TRANSLATE_Y_HP := new ImageTransformPNameHP($8158);
private static _IMAGE_ROTATE_ANGLE_HP := new ImageTransformPNameHP($8159);
private static _IMAGE_ROTATE_ORIGIN_X_HP := new ImageTransformPNameHP($815A);
private static _IMAGE_ROTATE_ORIGIN_Y_HP := new ImageTransformPNameHP($815B);
private static _IMAGE_MAG_FILTER_HP := new ImageTransformPNameHP($815C);
private static _IMAGE_MIN_FILTER_HP := new ImageTransformPNameHP($815D);
private static _IMAGE_CUBIC_WEIGHT_HP := new ImageTransformPNameHP($815E);
public static property IMAGE_SCALE_X_HP: ImageTransformPNameHP read _IMAGE_SCALE_X_HP;
public static property IMAGE_SCALE_Y_HP: ImageTransformPNameHP read _IMAGE_SCALE_Y_HP;
public static property IMAGE_TRANSLATE_X_HP: ImageTransformPNameHP read _IMAGE_TRANSLATE_X_HP;
public static property IMAGE_TRANSLATE_Y_HP: ImageTransformPNameHP read _IMAGE_TRANSLATE_Y_HP;
public static property IMAGE_ROTATE_ANGLE_HP: ImageTransformPNameHP read _IMAGE_ROTATE_ANGLE_HP;
public static property IMAGE_ROTATE_ORIGIN_X_HP: ImageTransformPNameHP read _IMAGE_ROTATE_ORIGIN_X_HP;
public static property IMAGE_ROTATE_ORIGIN_Y_HP: ImageTransformPNameHP read _IMAGE_ROTATE_ORIGIN_Y_HP;
public static property IMAGE_MAG_FILTER_HP: ImageTransformPNameHP read _IMAGE_MAG_FILTER_HP;
public static property IMAGE_MIN_FILTER_HP: ImageTransformPNameHP read _IMAGE_MIN_FILTER_HP;
public static property IMAGE_CUBIC_WEIGHT_HP: ImageTransformPNameHP read _IMAGE_CUBIC_WEIGHT_HP;
public function ToString: string; override;
begin
if self.val = UInt32($8155) then Result := 'IMAGE_SCALE_X_HP' else
if self.val = UInt32($8156) then Result := 'IMAGE_SCALE_Y_HP' else
if self.val = UInt32($8157) then Result := 'IMAGE_TRANSLATE_X_HP' else
if self.val = UInt32($8158) then Result := 'IMAGE_TRANSLATE_Y_HP' else
if self.val = UInt32($8159) then Result := 'IMAGE_ROTATE_ANGLE_HP' else
if self.val = UInt32($815A) then Result := 'IMAGE_ROTATE_ORIGIN_X_HP' else
if self.val = UInt32($815B) then Result := 'IMAGE_ROTATE_ORIGIN_Y_HP' else
if self.val = UInt32($815C) then Result := 'IMAGE_MAG_FILTER_HP' else
if self.val = UInt32($815D) then Result := 'IMAGE_MIN_FILTER_HP' else
if self.val = UInt32($815E) then Result := 'IMAGE_CUBIC_WEIGHT_HP' else
Result := self.val.ToString;
end;
end;
ImageTransformTargetHP = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _IMAGE_TRANSFORM_2D_HP := new ImageTransformTargetHP($8161);
public static property IMAGE_TRANSFORM_2D_HP: ImageTransformTargetHP read _IMAGE_TRANSFORM_2D_HP;
public function ToString: string; override;
begin
if self.val = UInt32($8161) then Result := 'IMAGE_TRANSFORM_2D_HP' else
Result := self.val.ToString;
end;
end;
{$endregion HP}
{$region IBM}
FogPointerTypeIBM = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLOAT := new FogPointerTypeIBM($1406);
private static _DOUBLE := new FogPointerTypeIBM($140A);
public static property FLOAT: FogPointerTypeIBM read _FLOAT;
public static property DOUBLE: FogPointerTypeIBM read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
SecondaryColorPointerTypeIBM = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SHORT := new SecondaryColorPointerTypeIBM($1402);
private static _INT := new SecondaryColorPointerTypeIBM($1404);
private static _FLOAT := new SecondaryColorPointerTypeIBM($1406);
private static _DOUBLE := new SecondaryColorPointerTypeIBM($140A);
public static property SHORT: SecondaryColorPointerTypeIBM read _SHORT;
public static property INT: SecondaryColorPointerTypeIBM read _INT;
public static property FLOAT: SecondaryColorPointerTypeIBM read _FLOAT;
public static property DOUBLE: SecondaryColorPointerTypeIBM read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1402) then Result := 'SHORT' else
if self.val = UInt32($1404) then Result := 'INT' else
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
{$endregion IBM}
{$region INTEL}
PerfQueryCapFlagsINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PERFQUERY_SINGLE_CONTEXT_INTEL := new PerfQueryCapFlagsINTEL($0000);
private static _PERFQUERY_GLOBAL_CONTEXT_INTEL := new PerfQueryCapFlagsINTEL($0001);
public static property PERFQUERY_SINGLE_CONTEXT_INTEL: PerfQueryCapFlagsINTEL read _PERFQUERY_SINGLE_CONTEXT_INTEL;
public static property PERFQUERY_GLOBAL_CONTEXT_INTEL: PerfQueryCapFlagsINTEL read _PERFQUERY_GLOBAL_CONTEXT_INTEL;
public static function operator or(f1,f2: PerfQueryCapFlagsINTEL) := new PerfQueryCapFlagsINTEL(f1.val or f2.val);
public property ANY_FLAGS: boolean read self.val<>0;
public property HAS_FLAG_PERFQUERY_GLOBAL_CONTEXT_INTEL: boolean read self.val and $0001 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0000) = UInt32($0000) then res += 'PERFQUERY_SINGLE_CONTEXT_INTEL+';
if self.val and UInt32($0001) = UInt32($0001) then res += 'PERFQUERY_GLOBAL_CONTEXT_INTEL+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
PerfQueryDataFlagsINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PERFQUERY_DONOT_FLUSH_INTEL := new PerfQueryDataFlagsINTEL($83F9);
private static _PERFQUERY_FLUSH_INTEL := new PerfQueryDataFlagsINTEL($83FA);
private static _PERFQUERY_WAIT_INTEL := new PerfQueryDataFlagsINTEL($83FB);
public static property PERFQUERY_DONOT_FLUSH_INTEL: PerfQueryDataFlagsINTEL read _PERFQUERY_DONOT_FLUSH_INTEL;
public static property PERFQUERY_FLUSH_INTEL: PerfQueryDataFlagsINTEL read _PERFQUERY_FLUSH_INTEL;
public static property PERFQUERY_WAIT_INTEL: PerfQueryDataFlagsINTEL read _PERFQUERY_WAIT_INTEL;
public function ToString: string; override;
begin
if self.val = UInt32($83F9) then Result := 'PERFQUERY_DONOT_FLUSH_INTEL' else
if self.val = UInt32($83FA) then Result := 'PERFQUERY_FLUSH_INTEL' else
if self.val = UInt32($83FB) then Result := 'PERFQUERY_WAIT_INTEL' else
Result := self.val.ToString;
end;
end;
{$endregion INTEL}
{$region NV}
CombinerBiasNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new CombinerBiasNV($0000);
private static _BIAS_BY_NEGATIVE_ONE_HALF_NV := new CombinerBiasNV($8541);
public static property NONE: CombinerBiasNV read _NONE;
public static property BIAS_BY_NEGATIVE_ONE_HALF_NV: CombinerBiasNV read _BIAS_BY_NEGATIVE_ONE_HALF_NV;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($8541) then Result := 'BIAS_BY_NEGATIVE_ONE_HALF_NV' else
Result := self.val.ToString;
end;
end;
CombinerComponentUsageNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _BLUE := new CombinerComponentUsageNV($1905);
private static _ALPHA := new CombinerComponentUsageNV($1906);
private static _RGB := new CombinerComponentUsageNV($1907);
public static property BLUE: CombinerComponentUsageNV read _BLUE;
public static property ALPHA: CombinerComponentUsageNV read _ALPHA;
public static property RGB: CombinerComponentUsageNV read _RGB;
public function ToString: string; override;
begin
if self.val = UInt32($1905) then Result := 'BLUE' else
if self.val = UInt32($1906) then Result := 'ALPHA' else
if self.val = UInt32($1907) then Result := 'RGB' else
Result := self.val.ToString;
end;
end;
CombinerMappingNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_IDENTITY_NV := new CombinerMappingNV($8536);
private static _UNSIGNED_INVERT_NV := new CombinerMappingNV($8537);
private static _EXPAND_NORMAL_NV := new CombinerMappingNV($8538);
private static _EXPAND_NEGATE_NV := new CombinerMappingNV($8539);
private static _HALF_BIAS_NORMAL_NV := new CombinerMappingNV($853A);
private static _HALF_BIAS_NEGATE_NV := new CombinerMappingNV($853B);
private static _SIGNED_IDENTITY_NV := new CombinerMappingNV($853C);
private static _SIGNED_NEGATE_NV := new CombinerMappingNV($853D);
public static property UNSIGNED_IDENTITY_NV: CombinerMappingNV read _UNSIGNED_IDENTITY_NV;
public static property UNSIGNED_INVERT_NV: CombinerMappingNV read _UNSIGNED_INVERT_NV;
public static property EXPAND_NORMAL_NV: CombinerMappingNV read _EXPAND_NORMAL_NV;
public static property EXPAND_NEGATE_NV: CombinerMappingNV read _EXPAND_NEGATE_NV;
public static property HALF_BIAS_NORMAL_NV: CombinerMappingNV read _HALF_BIAS_NORMAL_NV;
public static property HALF_BIAS_NEGATE_NV: CombinerMappingNV read _HALF_BIAS_NEGATE_NV;
public static property SIGNED_IDENTITY_NV: CombinerMappingNV read _SIGNED_IDENTITY_NV;
public static property SIGNED_NEGATE_NV: CombinerMappingNV read _SIGNED_NEGATE_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8536) then Result := 'UNSIGNED_IDENTITY_NV' else
if self.val = UInt32($8537) then Result := 'UNSIGNED_INVERT_NV' else
if self.val = UInt32($8538) then Result := 'EXPAND_NORMAL_NV' else
if self.val = UInt32($8539) then Result := 'EXPAND_NEGATE_NV' else
if self.val = UInt32($853A) then Result := 'HALF_BIAS_NORMAL_NV' else
if self.val = UInt32($853B) then Result := 'HALF_BIAS_NEGATE_NV' else
if self.val = UInt32($853C) then Result := 'SIGNED_IDENTITY_NV' else
if self.val = UInt32($853D) then Result := 'SIGNED_NEGATE_NV' else
Result := self.val.ToString;
end;
end;
CombinerParameterNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COMBINER_INPUT_NV := new CombinerParameterNV($8542);
private static _COMBINER_MAPPING_NV := new CombinerParameterNV($8543);
private static _COMBINER_COMPONENT_USAGE_NV := new CombinerParameterNV($8544);
public static property COMBINER_INPUT_NV: CombinerParameterNV read _COMBINER_INPUT_NV;
public static property COMBINER_MAPPING_NV: CombinerParameterNV read _COMBINER_MAPPING_NV;
public static property COMBINER_COMPONENT_USAGE_NV: CombinerParameterNV read _COMBINER_COMPONENT_USAGE_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8542) then Result := 'COMBINER_INPUT_NV' else
if self.val = UInt32($8543) then Result := 'COMBINER_MAPPING_NV' else
if self.val = UInt32($8544) then Result := 'COMBINER_COMPONENT_USAGE_NV' else
Result := self.val.ToString;
end;
end;
CombinerPortionNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ALPHA := new CombinerPortionNV($1906);
private static _RGB := new CombinerPortionNV($1907);
public static property ALPHA: CombinerPortionNV read _ALPHA;
public static property RGB: CombinerPortionNV read _RGB;
public function ToString: string; override;
begin
if self.val = UInt32($1906) then Result := 'ALPHA' else
if self.val = UInt32($1907) then Result := 'RGB' else
Result := self.val.ToString;
end;
end;
CombinerRegisterNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE0_ARB := new CombinerRegisterNV($84C0);
private static _TEXTURE1_ARB := new CombinerRegisterNV($84C1);
private static _PRIMARY_COLOR_NV := new CombinerRegisterNV($852C);
private static _SECONDARY_COLOR_NV := new CombinerRegisterNV($852D);
private static _SPARE0_NV := new CombinerRegisterNV($852E);
private static _SPARE1_NV := new CombinerRegisterNV($852F);
private static _DISCARD_NV := new CombinerRegisterNV($8530);
public static property TEXTURE0_ARB: CombinerRegisterNV read _TEXTURE0_ARB;
public static property TEXTURE1_ARB: CombinerRegisterNV read _TEXTURE1_ARB;
public static property PRIMARY_COLOR_NV: CombinerRegisterNV read _PRIMARY_COLOR_NV;
public static property SECONDARY_COLOR_NV: CombinerRegisterNV read _SECONDARY_COLOR_NV;
public static property SPARE0_NV: CombinerRegisterNV read _SPARE0_NV;
public static property SPARE1_NV: CombinerRegisterNV read _SPARE1_NV;
public static property DISCARD_NV: CombinerRegisterNV read _DISCARD_NV;
public function ToString: string; override;
begin
if self.val = UInt32($84C0) then Result := 'TEXTURE0_ARB' else
if self.val = UInt32($84C1) then Result := 'TEXTURE1_ARB' else
if self.val = UInt32($852C) then Result := 'PRIMARY_COLOR_NV' else
if self.val = UInt32($852D) then Result := 'SECONDARY_COLOR_NV' else
if self.val = UInt32($852E) then Result := 'SPARE0_NV' else
if self.val = UInt32($852F) then Result := 'SPARE1_NV' else
if self.val = UInt32($8530) then Result := 'DISCARD_NV' else
Result := self.val.ToString;
end;
end;
CombinerScaleNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _NONE := new CombinerScaleNV($0000);
private static _SCALE_BY_TWO_NV := new CombinerScaleNV($853E);
private static _SCALE_BY_FOUR_NV := new CombinerScaleNV($853F);
private static _SCALE_BY_ONE_HALF_NV := new CombinerScaleNV($8540);
public static property NONE: CombinerScaleNV read _NONE;
public static property SCALE_BY_TWO_NV: CombinerScaleNV read _SCALE_BY_TWO_NV;
public static property SCALE_BY_FOUR_NV: CombinerScaleNV read _SCALE_BY_FOUR_NV;
public static property SCALE_BY_ONE_HALF_NV: CombinerScaleNV read _SCALE_BY_ONE_HALF_NV;
public function ToString: string; override;
begin
if self.val = UInt32($0000) then Result := 'NONE' else
if self.val = UInt32($853E) then Result := 'SCALE_BY_TWO_NV' else
if self.val = UInt32($853F) then Result := 'SCALE_BY_FOUR_NV' else
if self.val = UInt32($8540) then Result := 'SCALE_BY_ONE_HALF_NV' else
Result := self.val.ToString;
end;
end;
CombinerStageNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COMBINER0_NV := new CombinerStageNV($8550);
private static _COMBINER1_NV := new CombinerStageNV($8551);
private static _COMBINER2_NV := new CombinerStageNV($8552);
private static _COMBINER3_NV := new CombinerStageNV($8553);
private static _COMBINER4_NV := new CombinerStageNV($8554);
private static _COMBINER5_NV := new CombinerStageNV($8555);
private static _COMBINER6_NV := new CombinerStageNV($8556);
private static _COMBINER7_NV := new CombinerStageNV($8557);
public static property COMBINER0_NV: CombinerStageNV read _COMBINER0_NV;
public static property COMBINER1_NV: CombinerStageNV read _COMBINER1_NV;
public static property COMBINER2_NV: CombinerStageNV read _COMBINER2_NV;
public static property COMBINER3_NV: CombinerStageNV read _COMBINER3_NV;
public static property COMBINER4_NV: CombinerStageNV read _COMBINER4_NV;
public static property COMBINER5_NV: CombinerStageNV read _COMBINER5_NV;
public static property COMBINER6_NV: CombinerStageNV read _COMBINER6_NV;
public static property COMBINER7_NV: CombinerStageNV read _COMBINER7_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8550) then Result := 'COMBINER0_NV' else
if self.val = UInt32($8551) then Result := 'COMBINER1_NV' else
if self.val = UInt32($8552) then Result := 'COMBINER2_NV' else
if self.val = UInt32($8553) then Result := 'COMBINER3_NV' else
if self.val = UInt32($8554) then Result := 'COMBINER4_NV' else
if self.val = UInt32($8555) then Result := 'COMBINER5_NV' else
if self.val = UInt32($8556) then Result := 'COMBINER6_NV' else
if self.val = UInt32($8557) then Result := 'COMBINER7_NV' else
Result := self.val.ToString;
end;
end;
CombinerVariableNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VARIABLE_A_NV := new CombinerVariableNV($8523);
private static _VARIABLE_B_NV := new CombinerVariableNV($8524);
private static _VARIABLE_C_NV := new CombinerVariableNV($8525);
private static _VARIABLE_D_NV := new CombinerVariableNV($8526);
private static _VARIABLE_E_NV := new CombinerVariableNV($8527);
private static _VARIABLE_F_NV := new CombinerVariableNV($8528);
private static _VARIABLE_G_NV := new CombinerVariableNV($8529);
public static property VARIABLE_A_NV: CombinerVariableNV read _VARIABLE_A_NV;
public static property VARIABLE_B_NV: CombinerVariableNV read _VARIABLE_B_NV;
public static property VARIABLE_C_NV: CombinerVariableNV read _VARIABLE_C_NV;
public static property VARIABLE_D_NV: CombinerVariableNV read _VARIABLE_D_NV;
public static property VARIABLE_E_NV: CombinerVariableNV read _VARIABLE_E_NV;
public static property VARIABLE_F_NV: CombinerVariableNV read _VARIABLE_F_NV;
public static property VARIABLE_G_NV: CombinerVariableNV read _VARIABLE_G_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8523) then Result := 'VARIABLE_A_NV' else
if self.val = UInt32($8524) then Result := 'VARIABLE_B_NV' else
if self.val = UInt32($8525) then Result := 'VARIABLE_C_NV' else
if self.val = UInt32($8526) then Result := 'VARIABLE_D_NV' else
if self.val = UInt32($8527) then Result := 'VARIABLE_E_NV' else
if self.val = UInt32($8528) then Result := 'VARIABLE_F_NV' else
if self.val = UInt32($8529) then Result := 'VARIABLE_G_NV' else
Result := self.val.ToString;
end;
end;
EvalMapsModeNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FILL_NV := new EvalMapsModeNV($1B02);
public static property FILL_NV: EvalMapsModeNV read _FILL_NV;
public function ToString: string; override;
begin
if self.val = UInt32($1B02) then Result := 'FILL_NV' else
Result := self.val.ToString;
end;
end;
EvalTargetNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _EVAL_2D_NV := new EvalTargetNV($86C0);
private static _EVAL_TRIANGULAR_2D_NV := new EvalTargetNV($86C1);
public static property EVAL_2D_NV: EvalTargetNV read _EVAL_2D_NV;
public static property EVAL_TRIANGULAR_2D_NV: EvalTargetNV read _EVAL_TRIANGULAR_2D_NV;
public function ToString: string; override;
begin
if self.val = UInt32($86C0) then Result := 'EVAL_2D_NV' else
if self.val = UInt32($86C1) then Result := 'EVAL_TRIANGULAR_2D_NV' else
Result := self.val.ToString;
end;
end;
FenceConditionNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _ALL_COMPLETED_NV := new FenceConditionNV($84F2);
public static property ALL_COMPLETED_NV: FenceConditionNV read _ALL_COMPLETED_NV;
public function ToString: string; override;
begin
if self.val = UInt32($84F2) then Result := 'ALL_COMPLETED_NV' else
Result := self.val.ToString;
end;
end;
FenceParameterNameNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FENCE_STATUS_NV := new FenceParameterNameNV($84F3);
private static _FENCE_CONDITION_NV := new FenceParameterNameNV($84F4);
public static property FENCE_STATUS_NV: FenceParameterNameNV read _FENCE_STATUS_NV;
public static property FENCE_CONDITION_NV: FenceParameterNameNV read _FENCE_CONDITION_NV;
public function ToString: string; override;
begin
if self.val = UInt32($84F3) then Result := 'FENCE_STATUS_NV' else
if self.val = UInt32($84F4) then Result := 'FENCE_CONDITION_NV' else
Result := self.val.ToString;
end;
end;
GetMultisamplePNameNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SAMPLE_LOCATION_ARB := new GetMultisamplePNameNV($8E50);
private static _SAMPLE_POSITION := new GetMultisamplePNameNV($8E50);
private static _PROGRAMMABLE_SAMPLE_LOCATION_ARB := new GetMultisamplePNameNV($9341);
public static property SAMPLE_LOCATION_ARB: GetMultisamplePNameNV read _SAMPLE_LOCATION_ARB;
public static property SAMPLE_POSITION: GetMultisamplePNameNV read _SAMPLE_POSITION;
public static property PROGRAMMABLE_SAMPLE_LOCATION_ARB: GetMultisamplePNameNV read _PROGRAMMABLE_SAMPLE_LOCATION_ARB;
public function ToString: string; override;
begin
if self.val = UInt32($8E50) then Result := 'SAMPLE_LOCATION_ARB' else
if self.val = UInt32($8E50) then Result := 'SAMPLE_POSITION' else
if self.val = UInt32($9341) then Result := 'PROGRAMMABLE_SAMPLE_LOCATION_ARB' else
Result := self.val.ToString;
end;
end;
MapAttribParameterNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP_ATTRIB_U_ORDER_NV := new MapAttribParameterNV($86C3);
private static _MAP_ATTRIB_V_ORDER_NV := new MapAttribParameterNV($86C4);
public static property MAP_ATTRIB_U_ORDER_NV: MapAttribParameterNV read _MAP_ATTRIB_U_ORDER_NV;
public static property MAP_ATTRIB_V_ORDER_NV: MapAttribParameterNV read _MAP_ATTRIB_V_ORDER_NV;
public function ToString: string; override;
begin
if self.val = UInt32($86C3) then Result := 'MAP_ATTRIB_U_ORDER_NV' else
if self.val = UInt32($86C4) then Result := 'MAP_ATTRIB_V_ORDER_NV' else
Result := self.val.ToString;
end;
end;
MapParameterNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _MAP_TESSELLATION_NV := new MapParameterNV($86C2);
public static property MAP_TESSELLATION_NV: MapParameterNV read _MAP_TESSELLATION_NV;
public function ToString: string; override;
begin
if self.val = UInt32($86C2) then Result := 'MAP_TESSELLATION_NV' else
Result := self.val.ToString;
end;
end;
MapTypeNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FLOAT := new MapTypeNV($1406);
private static _DOUBLE := new MapTypeNV($140A);
public static property FLOAT: MapTypeNV read _FLOAT;
public static property DOUBLE: MapTypeNV read _DOUBLE;
public function ToString: string; override;
begin
if self.val = UInt32($1406) then Result := 'FLOAT' else
if self.val = UInt32($140A) then Result := 'DOUBLE' else
Result := self.val.ToString;
end;
end;
OcclusionQueryParameterNameNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_COUNT_NV := new OcclusionQueryParameterNameNV($8866);
private static _PIXEL_COUNT_AVAILABLE_NV := new OcclusionQueryParameterNameNV($8867);
public static property PIXEL_COUNT_NV: OcclusionQueryParameterNameNV read _PIXEL_COUNT_NV;
public static property PIXEL_COUNT_AVAILABLE_NV: OcclusionQueryParameterNameNV read _PIXEL_COUNT_AVAILABLE_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8866) then Result := 'PIXEL_COUNT_NV' else
if self.val = UInt32($8867) then Result := 'PIXEL_COUNT_AVAILABLE_NV' else
Result := self.val.ToString;
end;
end;
PixelDataRangeTargetNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _WRITE_PIXEL_DATA_RANGE_NV := new PixelDataRangeTargetNV($8878);
private static _READ_PIXEL_DATA_RANGE_NV := new PixelDataRangeTargetNV($8879);
public static property WRITE_PIXEL_DATA_RANGE_NV: PixelDataRangeTargetNV read _WRITE_PIXEL_DATA_RANGE_NV;
public static property READ_PIXEL_DATA_RANGE_NV: PixelDataRangeTargetNV read _READ_PIXEL_DATA_RANGE_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8878) then Result := 'WRITE_PIXEL_DATA_RANGE_NV' else
if self.val = UInt32($8879) then Result := 'READ_PIXEL_DATA_RANGE_NV' else
Result := self.val.ToString;
end;
end;
VertexAttribEnumNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PROGRAM_PARAMETER_NV := new VertexAttribEnumNV($8644);
public static property PROGRAM_PARAMETER_NV: VertexAttribEnumNV read _PROGRAM_PARAMETER_NV;
public function ToString: string; override;
begin
if self.val = UInt32($8644) then Result := 'PROGRAM_PARAMETER_NV' else
Result := self.val.ToString;
end;
end;
{$endregion NV}
{$region PGI}
HintTargetPGI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _VERTEX_DATA_HINT_PGI := new HintTargetPGI($1A22A);
private static _VERTEX_CONSISTENT_HINT_PGI := new HintTargetPGI($1A22B);
private static _MATERIAL_SIDE_HINT_PGI := new HintTargetPGI($1A22C);
private static _MAX_VERTEX_HINT_PGI := new HintTargetPGI($1A22D);
public static property VERTEX_DATA_HINT_PGI: HintTargetPGI read _VERTEX_DATA_HINT_PGI;
public static property VERTEX_CONSISTENT_HINT_PGI: HintTargetPGI read _VERTEX_CONSISTENT_HINT_PGI;
public static property MATERIAL_SIDE_HINT_PGI: HintTargetPGI read _MATERIAL_SIDE_HINT_PGI;
public static property MAX_VERTEX_HINT_PGI: HintTargetPGI read _MAX_VERTEX_HINT_PGI;
public function ToString: string; override;
begin
if self.val = UInt32($1A22A) then Result := 'VERTEX_DATA_HINT_PGI' else
if self.val = UInt32($1A22B) then Result := 'VERTEX_CONSISTENT_HINT_PGI' else
if self.val = UInt32($1A22C) then Result := 'MATERIAL_SIDE_HINT_PGI' else
if self.val = UInt32($1A22D) then Result := 'MAX_VERTEX_HINT_PGI' else
Result := self.val.ToString;
end;
end;
{$endregion PGI}
{$region SGI}
ColorTableParameterPNameSGI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR_TABLE_SCALE := new ColorTableParameterPNameSGI($80D6);
private static _COLOR_TABLE_SCALE_SGI := new ColorTableParameterPNameSGI($80D6);
private static _COLOR_TABLE_BIAS := new ColorTableParameterPNameSGI($80D7);
private static _COLOR_TABLE_BIAS_SGI := new ColorTableParameterPNameSGI($80D7);
private static _COLOR_TABLE_FORMAT := new ColorTableParameterPNameSGI($80D8);
private static _COLOR_TABLE_FORMAT_SGI := new ColorTableParameterPNameSGI($80D8);
private static _COLOR_TABLE_WIDTH := new ColorTableParameterPNameSGI($80D9);
private static _COLOR_TABLE_WIDTH_SGI := new ColorTableParameterPNameSGI($80D9);
private static _COLOR_TABLE_RED_SIZE := new ColorTableParameterPNameSGI($80DA);
private static _COLOR_TABLE_RED_SIZE_SGI := new ColorTableParameterPNameSGI($80DA);
private static _COLOR_TABLE_GREEN_SIZE := new ColorTableParameterPNameSGI($80DB);
private static _COLOR_TABLE_GREEN_SIZE_SGI := new ColorTableParameterPNameSGI($80DB);
private static _COLOR_TABLE_BLUE_SIZE := new ColorTableParameterPNameSGI($80DC);
private static _COLOR_TABLE_BLUE_SIZE_SGI := new ColorTableParameterPNameSGI($80DC);
private static _COLOR_TABLE_ALPHA_SIZE := new ColorTableParameterPNameSGI($80DD);
private static _COLOR_TABLE_ALPHA_SIZE_SGI := new ColorTableParameterPNameSGI($80DD);
private static _COLOR_TABLE_LUMINANCE_SIZE := new ColorTableParameterPNameSGI($80DE);
private static _COLOR_TABLE_LUMINANCE_SIZE_SGI := new ColorTableParameterPNameSGI($80DE);
private static _COLOR_TABLE_INTENSITY_SIZE := new ColorTableParameterPNameSGI($80DF);
private static _COLOR_TABLE_INTENSITY_SIZE_SGI := new ColorTableParameterPNameSGI($80DF);
public static property COLOR_TABLE_SCALE: ColorTableParameterPNameSGI read _COLOR_TABLE_SCALE;
public static property COLOR_TABLE_SCALE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_SCALE_SGI;
public static property COLOR_TABLE_BIAS: ColorTableParameterPNameSGI read _COLOR_TABLE_BIAS;
public static property COLOR_TABLE_BIAS_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_BIAS_SGI;
public static property COLOR_TABLE_FORMAT: ColorTableParameterPNameSGI read _COLOR_TABLE_FORMAT;
public static property COLOR_TABLE_FORMAT_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_FORMAT_SGI;
public static property COLOR_TABLE_WIDTH: ColorTableParameterPNameSGI read _COLOR_TABLE_WIDTH;
public static property COLOR_TABLE_WIDTH_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_WIDTH_SGI;
public static property COLOR_TABLE_RED_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_RED_SIZE;
public static property COLOR_TABLE_RED_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_RED_SIZE_SGI;
public static property COLOR_TABLE_GREEN_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_GREEN_SIZE;
public static property COLOR_TABLE_GREEN_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_GREEN_SIZE_SGI;
public static property COLOR_TABLE_BLUE_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_BLUE_SIZE;
public static property COLOR_TABLE_BLUE_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_BLUE_SIZE_SGI;
public static property COLOR_TABLE_ALPHA_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_ALPHA_SIZE;
public static property COLOR_TABLE_ALPHA_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_ALPHA_SIZE_SGI;
public static property COLOR_TABLE_LUMINANCE_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_LUMINANCE_SIZE;
public static property COLOR_TABLE_LUMINANCE_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_LUMINANCE_SIZE_SGI;
public static property COLOR_TABLE_INTENSITY_SIZE: ColorTableParameterPNameSGI read _COLOR_TABLE_INTENSITY_SIZE;
public static property COLOR_TABLE_INTENSITY_SIZE_SGI: ColorTableParameterPNameSGI read _COLOR_TABLE_INTENSITY_SIZE_SGI;
public function ToString: string; override;
begin
if self.val = UInt32($80D6) then Result := 'COLOR_TABLE_SCALE' else
if self.val = UInt32($80D6) then Result := 'COLOR_TABLE_SCALE_SGI' else
if self.val = UInt32($80D7) then Result := 'COLOR_TABLE_BIAS' else
if self.val = UInt32($80D7) then Result := 'COLOR_TABLE_BIAS_SGI' else
if self.val = UInt32($80D8) then Result := 'COLOR_TABLE_FORMAT' else
if self.val = UInt32($80D8) then Result := 'COLOR_TABLE_FORMAT_SGI' else
if self.val = UInt32($80D9) then Result := 'COLOR_TABLE_WIDTH' else
if self.val = UInt32($80D9) then Result := 'COLOR_TABLE_WIDTH_SGI' else
if self.val = UInt32($80DA) then Result := 'COLOR_TABLE_RED_SIZE' else
if self.val = UInt32($80DA) then Result := 'COLOR_TABLE_RED_SIZE_SGI' else
if self.val = UInt32($80DB) then Result := 'COLOR_TABLE_GREEN_SIZE' else
if self.val = UInt32($80DB) then Result := 'COLOR_TABLE_GREEN_SIZE_SGI' else
if self.val = UInt32($80DC) then Result := 'COLOR_TABLE_BLUE_SIZE' else
if self.val = UInt32($80DC) then Result := 'COLOR_TABLE_BLUE_SIZE_SGI' else
if self.val = UInt32($80DD) then Result := 'COLOR_TABLE_ALPHA_SIZE' else
if self.val = UInt32($80DD) then Result := 'COLOR_TABLE_ALPHA_SIZE_SGI' else
if self.val = UInt32($80DE) then Result := 'COLOR_TABLE_LUMINANCE_SIZE' else
if self.val = UInt32($80DE) then Result := 'COLOR_TABLE_LUMINANCE_SIZE_SGI' else
if self.val = UInt32($80DF) then Result := 'COLOR_TABLE_INTENSITY_SIZE' else
if self.val = UInt32($80DF) then Result := 'COLOR_TABLE_INTENSITY_SIZE_SGI' else
Result := self.val.ToString;
end;
end;
ColorTableTargetSGI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_COLOR_TABLE_SGI := new ColorTableTargetSGI($80BC);
private static _PROXY_TEXTURE_COLOR_TABLE_SGI := new ColorTableTargetSGI($80BD);
private static _COLOR_TABLE := new ColorTableTargetSGI($80D0);
private static _COLOR_TABLE_SGI := new ColorTableTargetSGI($80D0);
private static _POST_CONVOLUTION_COLOR_TABLE := new ColorTableTargetSGI($80D1);
private static _POST_CONVOLUTION_COLOR_TABLE_SGI := new ColorTableTargetSGI($80D1);
private static _POST_COLOR_MATRIX_COLOR_TABLE := new ColorTableTargetSGI($80D2);
private static _POST_COLOR_MATRIX_COLOR_TABLE_SGI := new ColorTableTargetSGI($80D2);
private static _PROXY_COLOR_TABLE := new ColorTableTargetSGI($80D3);
private static _PROXY_COLOR_TABLE_SGI := new ColorTableTargetSGI($80D3);
private static _PROXY_POST_CONVOLUTION_COLOR_TABLE := new ColorTableTargetSGI($80D4);
private static _PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI := new ColorTableTargetSGI($80D4);
private static _PROXY_POST_COLOR_MATRIX_COLOR_TABLE := new ColorTableTargetSGI($80D5);
private static _PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI := new ColorTableTargetSGI($80D5);
public static property TEXTURE_COLOR_TABLE_SGI: ColorTableTargetSGI read _TEXTURE_COLOR_TABLE_SGI;
public static property PROXY_TEXTURE_COLOR_TABLE_SGI: ColorTableTargetSGI read _PROXY_TEXTURE_COLOR_TABLE_SGI;
public static property COLOR_TABLE: ColorTableTargetSGI read _COLOR_TABLE;
public static property COLOR_TABLE_SGI: ColorTableTargetSGI read _COLOR_TABLE_SGI;
public static property POST_CONVOLUTION_COLOR_TABLE: ColorTableTargetSGI read _POST_CONVOLUTION_COLOR_TABLE;
public static property POST_CONVOLUTION_COLOR_TABLE_SGI: ColorTableTargetSGI read _POST_CONVOLUTION_COLOR_TABLE_SGI;
public static property POST_COLOR_MATRIX_COLOR_TABLE: ColorTableTargetSGI read _POST_COLOR_MATRIX_COLOR_TABLE;
public static property POST_COLOR_MATRIX_COLOR_TABLE_SGI: ColorTableTargetSGI read _POST_COLOR_MATRIX_COLOR_TABLE_SGI;
public static property PROXY_COLOR_TABLE: ColorTableTargetSGI read _PROXY_COLOR_TABLE;
public static property PROXY_COLOR_TABLE_SGI: ColorTableTargetSGI read _PROXY_COLOR_TABLE_SGI;
public static property PROXY_POST_CONVOLUTION_COLOR_TABLE: ColorTableTargetSGI read _PROXY_POST_CONVOLUTION_COLOR_TABLE;
public static property PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI: ColorTableTargetSGI read _PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI;
public static property PROXY_POST_COLOR_MATRIX_COLOR_TABLE: ColorTableTargetSGI read _PROXY_POST_COLOR_MATRIX_COLOR_TABLE;
public static property PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI: ColorTableTargetSGI read _PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI;
public function ToString: string; override;
begin
if self.val = UInt32($80BC) then Result := 'TEXTURE_COLOR_TABLE_SGI' else
if self.val = UInt32($80BD) then Result := 'PROXY_TEXTURE_COLOR_TABLE_SGI' else
if self.val = UInt32($80D0) then Result := 'COLOR_TABLE' else
if self.val = UInt32($80D0) then Result := 'COLOR_TABLE_SGI' else
if self.val = UInt32($80D1) then Result := 'POST_CONVOLUTION_COLOR_TABLE' else
if self.val = UInt32($80D1) then Result := 'POST_CONVOLUTION_COLOR_TABLE_SGI' else
if self.val = UInt32($80D2) then Result := 'POST_COLOR_MATRIX_COLOR_TABLE' else
if self.val = UInt32($80D2) then Result := 'POST_COLOR_MATRIX_COLOR_TABLE_SGI' else
if self.val = UInt32($80D3) then Result := 'PROXY_COLOR_TABLE' else
if self.val = UInt32($80D3) then Result := 'PROXY_COLOR_TABLE_SGI' else
if self.val = UInt32($80D4) then Result := 'PROXY_POST_CONVOLUTION_COLOR_TABLE' else
if self.val = UInt32($80D4) then Result := 'PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI' else
if self.val = UInt32($80D5) then Result := 'PROXY_POST_COLOR_MATRIX_COLOR_TABLE' else
if self.val = UInt32($80D5) then Result := 'PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI' else
Result := self.val.ToString;
end;
end;
GetColorTableParameterPNameSGI = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _COLOR_TABLE_SCALE := new GetColorTableParameterPNameSGI($80D6);
private static _COLOR_TABLE_SCALE_SGI := new GetColorTableParameterPNameSGI($80D6);
private static _COLOR_TABLE_BIAS := new GetColorTableParameterPNameSGI($80D7);
private static _COLOR_TABLE_BIAS_SGI := new GetColorTableParameterPNameSGI($80D7);
private static _COLOR_TABLE_FORMAT := new GetColorTableParameterPNameSGI($80D8);
private static _COLOR_TABLE_FORMAT_SGI := new GetColorTableParameterPNameSGI($80D8);
private static _COLOR_TABLE_WIDTH := new GetColorTableParameterPNameSGI($80D9);
private static _COLOR_TABLE_WIDTH_SGI := new GetColorTableParameterPNameSGI($80D9);
private static _COLOR_TABLE_RED_SIZE := new GetColorTableParameterPNameSGI($80DA);
private static _COLOR_TABLE_RED_SIZE_SGI := new GetColorTableParameterPNameSGI($80DA);
private static _COLOR_TABLE_GREEN_SIZE := new GetColorTableParameterPNameSGI($80DB);
private static _COLOR_TABLE_GREEN_SIZE_SGI := new GetColorTableParameterPNameSGI($80DB);
private static _COLOR_TABLE_BLUE_SIZE := new GetColorTableParameterPNameSGI($80DC);
private static _COLOR_TABLE_BLUE_SIZE_SGI := new GetColorTableParameterPNameSGI($80DC);
private static _COLOR_TABLE_ALPHA_SIZE := new GetColorTableParameterPNameSGI($80DD);
private static _COLOR_TABLE_ALPHA_SIZE_SGI := new GetColorTableParameterPNameSGI($80DD);
private static _COLOR_TABLE_LUMINANCE_SIZE := new GetColorTableParameterPNameSGI($80DE);
private static _COLOR_TABLE_LUMINANCE_SIZE_SGI := new GetColorTableParameterPNameSGI($80DE);
private static _COLOR_TABLE_INTENSITY_SIZE := new GetColorTableParameterPNameSGI($80DF);
private static _COLOR_TABLE_INTENSITY_SIZE_SGI := new GetColorTableParameterPNameSGI($80DF);
public static property COLOR_TABLE_SCALE: GetColorTableParameterPNameSGI read _COLOR_TABLE_SCALE;
public static property COLOR_TABLE_SCALE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_SCALE_SGI;
public static property COLOR_TABLE_BIAS: GetColorTableParameterPNameSGI read _COLOR_TABLE_BIAS;
public static property COLOR_TABLE_BIAS_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_BIAS_SGI;
public static property COLOR_TABLE_FORMAT: GetColorTableParameterPNameSGI read _COLOR_TABLE_FORMAT;
public static property COLOR_TABLE_FORMAT_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_FORMAT_SGI;
public static property COLOR_TABLE_WIDTH: GetColorTableParameterPNameSGI read _COLOR_TABLE_WIDTH;
public static property COLOR_TABLE_WIDTH_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_WIDTH_SGI;
public static property COLOR_TABLE_RED_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_RED_SIZE;
public static property COLOR_TABLE_RED_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_RED_SIZE_SGI;
public static property COLOR_TABLE_GREEN_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_GREEN_SIZE;
public static property COLOR_TABLE_GREEN_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_GREEN_SIZE_SGI;
public static property COLOR_TABLE_BLUE_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_BLUE_SIZE;
public static property COLOR_TABLE_BLUE_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_BLUE_SIZE_SGI;
public static property COLOR_TABLE_ALPHA_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_ALPHA_SIZE;
public static property COLOR_TABLE_ALPHA_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_ALPHA_SIZE_SGI;
public static property COLOR_TABLE_LUMINANCE_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_LUMINANCE_SIZE;
public static property COLOR_TABLE_LUMINANCE_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_LUMINANCE_SIZE_SGI;
public static property COLOR_TABLE_INTENSITY_SIZE: GetColorTableParameterPNameSGI read _COLOR_TABLE_INTENSITY_SIZE;
public static property COLOR_TABLE_INTENSITY_SIZE_SGI: GetColorTableParameterPNameSGI read _COLOR_TABLE_INTENSITY_SIZE_SGI;
public function ToString: string; override;
begin
if self.val = UInt32($80D6) then Result := 'COLOR_TABLE_SCALE' else
if self.val = UInt32($80D6) then Result := 'COLOR_TABLE_SCALE_SGI' else
if self.val = UInt32($80D7) then Result := 'COLOR_TABLE_BIAS' else
if self.val = UInt32($80D7) then Result := 'COLOR_TABLE_BIAS_SGI' else
if self.val = UInt32($80D8) then Result := 'COLOR_TABLE_FORMAT' else
if self.val = UInt32($80D8) then Result := 'COLOR_TABLE_FORMAT_SGI' else
if self.val = UInt32($80D9) then Result := 'COLOR_TABLE_WIDTH' else
if self.val = UInt32($80D9) then Result := 'COLOR_TABLE_WIDTH_SGI' else
if self.val = UInt32($80DA) then Result := 'COLOR_TABLE_RED_SIZE' else
if self.val = UInt32($80DA) then Result := 'COLOR_TABLE_RED_SIZE_SGI' else
if self.val = UInt32($80DB) then Result := 'COLOR_TABLE_GREEN_SIZE' else
if self.val = UInt32($80DB) then Result := 'COLOR_TABLE_GREEN_SIZE_SGI' else
if self.val = UInt32($80DC) then Result := 'COLOR_TABLE_BLUE_SIZE' else
if self.val = UInt32($80DC) then Result := 'COLOR_TABLE_BLUE_SIZE_SGI' else
if self.val = UInt32($80DD) then Result := 'COLOR_TABLE_ALPHA_SIZE' else
if self.val = UInt32($80DD) then Result := 'COLOR_TABLE_ALPHA_SIZE_SGI' else
if self.val = UInt32($80DE) then Result := 'COLOR_TABLE_LUMINANCE_SIZE' else
if self.val = UInt32($80DE) then Result := 'COLOR_TABLE_LUMINANCE_SIZE_SGI' else
if self.val = UInt32($80DF) then Result := 'COLOR_TABLE_INTENSITY_SIZE' else
if self.val = UInt32($80DF) then Result := 'COLOR_TABLE_INTENSITY_SIZE_SGI' else
Result := self.val.ToString;
end;
end;
{$endregion SGI}
{$region SGIS}
PixelTexGenParameterNameSGIS = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_FRAGMENT_RGB_SOURCE_SGIS := new PixelTexGenParameterNameSGIS($8354);
private static _PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS := new PixelTexGenParameterNameSGIS($8355);
public static property PIXEL_FRAGMENT_RGB_SOURCE_SGIS: PixelTexGenParameterNameSGIS read _PIXEL_FRAGMENT_RGB_SOURCE_SGIS;
public static property PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS: PixelTexGenParameterNameSGIS read _PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS;
public function ToString: string; override;
begin
if self.val = UInt32($8354) then Result := 'PIXEL_FRAGMENT_RGB_SOURCE_SGIS' else
if self.val = UInt32($8355) then Result := 'PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS' else
Result := self.val.ToString;
end;
end;
SamplePatternSGIS = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _GL_1PASS_EXT := new SamplePatternSGIS($80A1);
private static _GL_1PASS_SGIS := new SamplePatternSGIS($80A1);
private static _GL_2PASS_0_EXT := new SamplePatternSGIS($80A2);
private static _GL_2PASS_0_SGIS := new SamplePatternSGIS($80A2);
private static _GL_2PASS_1_EXT := new SamplePatternSGIS($80A3);
private static _GL_2PASS_1_SGIS := new SamplePatternSGIS($80A3);
private static _GL_4PASS_0_EXT := new SamplePatternSGIS($80A4);
private static _GL_4PASS_0_SGIS := new SamplePatternSGIS($80A4);
private static _GL_4PASS_1_EXT := new SamplePatternSGIS($80A5);
private static _GL_4PASS_1_SGIS := new SamplePatternSGIS($80A5);
private static _GL_4PASS_2_EXT := new SamplePatternSGIS($80A6);
private static _GL_4PASS_2_SGIS := new SamplePatternSGIS($80A6);
private static _GL_4PASS_3_EXT := new SamplePatternSGIS($80A7);
private static _GL_4PASS_3_SGIS := new SamplePatternSGIS($80A7);
public static property GL_1PASS_EXT: SamplePatternSGIS read _GL_1PASS_EXT;
public static property GL_1PASS_SGIS: SamplePatternSGIS read _GL_1PASS_SGIS;
public static property GL_2PASS_0_EXT: SamplePatternSGIS read _GL_2PASS_0_EXT;
public static property GL_2PASS_0_SGIS: SamplePatternSGIS read _GL_2PASS_0_SGIS;
public static property GL_2PASS_1_EXT: SamplePatternSGIS read _GL_2PASS_1_EXT;
public static property GL_2PASS_1_SGIS: SamplePatternSGIS read _GL_2PASS_1_SGIS;
public static property GL_4PASS_0_EXT: SamplePatternSGIS read _GL_4PASS_0_EXT;
public static property GL_4PASS_0_SGIS: SamplePatternSGIS read _GL_4PASS_0_SGIS;
public static property GL_4PASS_1_EXT: SamplePatternSGIS read _GL_4PASS_1_EXT;
public static property GL_4PASS_1_SGIS: SamplePatternSGIS read _GL_4PASS_1_SGIS;
public static property GL_4PASS_2_EXT: SamplePatternSGIS read _GL_4PASS_2_EXT;
public static property GL_4PASS_2_SGIS: SamplePatternSGIS read _GL_4PASS_2_SGIS;
public static property GL_4PASS_3_EXT: SamplePatternSGIS read _GL_4PASS_3_EXT;
public static property GL_4PASS_3_SGIS: SamplePatternSGIS read _GL_4PASS_3_SGIS;
public function ToString: string; override;
begin
if self.val = UInt32($80A1) then Result := 'GL_1PASS_EXT' else
if self.val = UInt32($80A1) then Result := 'GL_1PASS_SGIS' else
if self.val = UInt32($80A2) then Result := 'GL_2PASS_0_EXT' else
if self.val = UInt32($80A2) then Result := 'GL_2PASS_0_SGIS' else
if self.val = UInt32($80A3) then Result := 'GL_2PASS_1_EXT' else
if self.val = UInt32($80A3) then Result := 'GL_2PASS_1_SGIS' else
if self.val = UInt32($80A4) then Result := 'GL_4PASS_0_EXT' else
if self.val = UInt32($80A4) then Result := 'GL_4PASS_0_SGIS' else
if self.val = UInt32($80A5) then Result := 'GL_4PASS_1_EXT' else
if self.val = UInt32($80A5) then Result := 'GL_4PASS_1_SGIS' else
if self.val = UInt32($80A6) then Result := 'GL_4PASS_2_EXT' else
if self.val = UInt32($80A6) then Result := 'GL_4PASS_2_SGIS' else
if self.val = UInt32($80A7) then Result := 'GL_4PASS_3_EXT' else
if self.val = UInt32($80A7) then Result := 'GL_4PASS_3_SGIS' else
Result := self.val.ToString;
end;
end;
TextureFilterSGIS = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FILTER4_SGIS := new TextureFilterSGIS($8146);
public static property FILTER4_SGIS: TextureFilterSGIS read _FILTER4_SGIS;
public function ToString: string; override;
begin
if self.val = UInt32($8146) then Result := 'FILTER4_SGIS' else
Result := self.val.ToString;
end;
end;
{$endregion SGIS}
{$region SGIX}
FfdMaskSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _TEXTURE_DEFORMATION_BIT_SGIX := new FfdMaskSGIX($0001);
private static _GEOMETRY_DEFORMATION_BIT_SGIX := new FfdMaskSGIX($0002);
public static property TEXTURE_DEFORMATION_BIT_SGIX: FfdMaskSGIX read _TEXTURE_DEFORMATION_BIT_SGIX;
public static property GEOMETRY_DEFORMATION_BIT_SGIX: FfdMaskSGIX read _GEOMETRY_DEFORMATION_BIT_SGIX;
public static function operator or(f1,f2: FfdMaskSGIX) := new FfdMaskSGIX(f1.val or f2.val);
public property HAS_FLAG_TEXTURE_DEFORMATION_BIT_SGIX: boolean read self.val and $0001 <> 0;
public property HAS_FLAG_GEOMETRY_DEFORMATION_BIT_SGIX: boolean read self.val and $0002 <> 0;
public function ToString: string; override;
begin
var res := new StringBuilder;
if self.val and UInt32($0001) = UInt32($0001) then res += 'TEXTURE_DEFORMATION_BIT_SGIX+';
if self.val and UInt32($0002) = UInt32($0002) then res += 'GEOMETRY_DEFORMATION_BIT_SGIX+';
if res.Length<>0 then
begin
res.Length -= 1;
Result := res.ToString;
end else
Result := self.val.ToString;
end;
end;
FfdTargetSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _GEOMETRY_DEFORMATION_SGIX := new FfdTargetSGIX($8194);
private static _TEXTURE_DEFORMATION_SGIX := new FfdTargetSGIX($8195);
public static property GEOMETRY_DEFORMATION_SGIX: FfdTargetSGIX read _GEOMETRY_DEFORMATION_SGIX;
public static property TEXTURE_DEFORMATION_SGIX: FfdTargetSGIX read _TEXTURE_DEFORMATION_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8194) then Result := 'GEOMETRY_DEFORMATION_SGIX' else
if self.val = UInt32($8195) then Result := 'TEXTURE_DEFORMATION_SGIX' else
Result := self.val.ToString;
end;
end;
FragmentLightModelParameterSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX := new FragmentLightModelParameterSGIX($8408);
private static _FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX := new FragmentLightModelParameterSGIX($8409);
private static _FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX := new FragmentLightModelParameterSGIX($840A);
private static _FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX := new FragmentLightModelParameterSGIX($840B);
public static property FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX: FragmentLightModelParameterSGIX read _FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX;
public static property FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX: FragmentLightModelParameterSGIX read _FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX;
public static property FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX: FragmentLightModelParameterSGIX read _FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX;
public static property FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX: FragmentLightModelParameterSGIX read _FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8408) then Result := 'FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX' else
if self.val = UInt32($8409) then Result := 'FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX' else
if self.val = UInt32($840A) then Result := 'FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX' else
if self.val = UInt32($840B) then Result := 'FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX' else
Result := self.val.ToString;
end;
end;
FragmentLightNameSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _FRAGMENT_LIGHT0_SGIX := new FragmentLightNameSGIX($840C);
private static _FRAGMENT_LIGHT1_SGIX := new FragmentLightNameSGIX($840D);
private static _FRAGMENT_LIGHT2_SGIX := new FragmentLightNameSGIX($840E);
private static _FRAGMENT_LIGHT3_SGIX := new FragmentLightNameSGIX($840F);
private static _FRAGMENT_LIGHT4_SGIX := new FragmentLightNameSGIX($8410);
private static _FRAGMENT_LIGHT5_SGIX := new FragmentLightNameSGIX($8411);
private static _FRAGMENT_LIGHT6_SGIX := new FragmentLightNameSGIX($8412);
private static _FRAGMENT_LIGHT7_SGIX := new FragmentLightNameSGIX($8413);
public static property FRAGMENT_LIGHT0_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT0_SGIX;
public static property FRAGMENT_LIGHT1_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT1_SGIX;
public static property FRAGMENT_LIGHT2_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT2_SGIX;
public static property FRAGMENT_LIGHT3_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT3_SGIX;
public static property FRAGMENT_LIGHT4_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT4_SGIX;
public static property FRAGMENT_LIGHT5_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT5_SGIX;
public static property FRAGMENT_LIGHT6_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT6_SGIX;
public static property FRAGMENT_LIGHT7_SGIX: FragmentLightNameSGIX read _FRAGMENT_LIGHT7_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($840C) then Result := 'FRAGMENT_LIGHT0_SGIX' else
if self.val = UInt32($840D) then Result := 'FRAGMENT_LIGHT1_SGIX' else
if self.val = UInt32($840E) then Result := 'FRAGMENT_LIGHT2_SGIX' else
if self.val = UInt32($840F) then Result := 'FRAGMENT_LIGHT3_SGIX' else
if self.val = UInt32($8410) then Result := 'FRAGMENT_LIGHT4_SGIX' else
if self.val = UInt32($8411) then Result := 'FRAGMENT_LIGHT5_SGIX' else
if self.val = UInt32($8412) then Result := 'FRAGMENT_LIGHT6_SGIX' else
if self.val = UInt32($8413) then Result := 'FRAGMENT_LIGHT7_SGIX' else
Result := self.val.ToString;
end;
end;
FragmentLightParameterSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _AMBIENT := new FragmentLightParameterSGIX($1200);
private static _DIFFUSE := new FragmentLightParameterSGIX($1201);
private static _SPECULAR := new FragmentLightParameterSGIX($1202);
private static _POSITION := new FragmentLightParameterSGIX($1203);
private static _SPOT_DIRECTION := new FragmentLightParameterSGIX($1204);
private static _SPOT_EXPONENT := new FragmentLightParameterSGIX($1205);
private static _SPOT_CUTOFF := new FragmentLightParameterSGIX($1206);
private static _CONSTANT_ATTENUATION := new FragmentLightParameterSGIX($1207);
private static _LINEAR_ATTENUATION := new FragmentLightParameterSGIX($1208);
private static _QUADRATIC_ATTENUATION := new FragmentLightParameterSGIX($1209);
public static property AMBIENT: FragmentLightParameterSGIX read _AMBIENT;
public static property DIFFUSE: FragmentLightParameterSGIX read _DIFFUSE;
public static property SPECULAR: FragmentLightParameterSGIX read _SPECULAR;
public static property POSITION: FragmentLightParameterSGIX read _POSITION;
public static property SPOT_DIRECTION: FragmentLightParameterSGIX read _SPOT_DIRECTION;
public static property SPOT_EXPONENT: FragmentLightParameterSGIX read _SPOT_EXPONENT;
public static property SPOT_CUTOFF: FragmentLightParameterSGIX read _SPOT_CUTOFF;
public static property CONSTANT_ATTENUATION: FragmentLightParameterSGIX read _CONSTANT_ATTENUATION;
public static property LINEAR_ATTENUATION: FragmentLightParameterSGIX read _LINEAR_ATTENUATION;
public static property QUADRATIC_ATTENUATION: FragmentLightParameterSGIX read _QUADRATIC_ATTENUATION;
public function ToString: string; override;
begin
if self.val = UInt32($1200) then Result := 'AMBIENT' else
if self.val = UInt32($1201) then Result := 'DIFFUSE' else
if self.val = UInt32($1202) then Result := 'SPECULAR' else
if self.val = UInt32($1203) then Result := 'POSITION' else
if self.val = UInt32($1204) then Result := 'SPOT_DIRECTION' else
if self.val = UInt32($1205) then Result := 'SPOT_EXPONENT' else
if self.val = UInt32($1206) then Result := 'SPOT_CUTOFF' else
if self.val = UInt32($1207) then Result := 'CONSTANT_ATTENUATION' else
if self.val = UInt32($1208) then Result := 'LINEAR_ATTENUATION' else
if self.val = UInt32($1209) then Result := 'QUADRATIC_ATTENUATION' else
Result := self.val.ToString;
end;
end;
LightEnvParameterSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _LIGHT_ENV_MODE_SGIX := new LightEnvParameterSGIX($8407);
public static property LIGHT_ENV_MODE_SGIX: LightEnvParameterSGIX read _LIGHT_ENV_MODE_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8407) then Result := 'LIGHT_ENV_MODE_SGIX' else
Result := self.val.ToString;
end;
end;
PixelTexGenModeSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _PIXEL_TEX_GEN_Q_CEILING_SGIX := new PixelTexGenModeSGIX($8184);
private static _PIXEL_TEX_GEN_Q_ROUND_SGIX := new PixelTexGenModeSGIX($8185);
private static _PIXEL_TEX_GEN_Q_FLOOR_SGIX := new PixelTexGenModeSGIX($8186);
private static _PIXEL_TEX_GEN_ALPHA_LS_SGIX := new PixelTexGenModeSGIX($8189);
private static _PIXEL_TEX_GEN_ALPHA_MS_SGIX := new PixelTexGenModeSGIX($818A);
public static property PIXEL_TEX_GEN_Q_CEILING_SGIX: PixelTexGenModeSGIX read _PIXEL_TEX_GEN_Q_CEILING_SGIX;
public static property PIXEL_TEX_GEN_Q_ROUND_SGIX: PixelTexGenModeSGIX read _PIXEL_TEX_GEN_Q_ROUND_SGIX;
public static property PIXEL_TEX_GEN_Q_FLOOR_SGIX: PixelTexGenModeSGIX read _PIXEL_TEX_GEN_Q_FLOOR_SGIX;
public static property PIXEL_TEX_GEN_ALPHA_LS_SGIX: PixelTexGenModeSGIX read _PIXEL_TEX_GEN_ALPHA_LS_SGIX;
public static property PIXEL_TEX_GEN_ALPHA_MS_SGIX: PixelTexGenModeSGIX read _PIXEL_TEX_GEN_ALPHA_MS_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8184) then Result := 'PIXEL_TEX_GEN_Q_CEILING_SGIX' else
if self.val = UInt32($8185) then Result := 'PIXEL_TEX_GEN_Q_ROUND_SGIX' else
if self.val = UInt32($8186) then Result := 'PIXEL_TEX_GEN_Q_FLOOR_SGIX' else
if self.val = UInt32($8189) then Result := 'PIXEL_TEX_GEN_ALPHA_LS_SGIX' else
if self.val = UInt32($818A) then Result := 'PIXEL_TEX_GEN_ALPHA_MS_SGIX' else
Result := self.val.ToString;
end;
end;
SpriteParameterNameSGIX = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _SPRITE_MODE_SGIX := new SpriteParameterNameSGIX($8149);
public static property SPRITE_MODE_SGIX: SpriteParameterNameSGIX read _SPRITE_MODE_SGIX;
public function ToString: string; override;
begin
if self.val = UInt32($8149) then Result := 'SPRITE_MODE_SGIX' else
Result := self.val.ToString;
end;
end;
{$endregion SGIX}
{$region SUN}
ReplacementCodeTypeSUN = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
private static _UNSIGNED_BYTE := new ReplacementCodeTypeSUN($1401);
private static _UNSIGNED_SHORT := new ReplacementCodeTypeSUN($1403);
private static _UNSIGNED_INT := new ReplacementCodeTypeSUN($1405);
public static property UNSIGNED_BYTE: ReplacementCodeTypeSUN read _UNSIGNED_BYTE;
public static property UNSIGNED_SHORT: ReplacementCodeTypeSUN read _UNSIGNED_SHORT;
public static property UNSIGNED_INT: ReplacementCodeTypeSUN read _UNSIGNED_INT;
public function ToString: string; override;
begin
if self.val = UInt32($1401) then Result := 'UNSIGNED_BYTE' else
if self.val = UInt32($1403) then Result := 'UNSIGNED_SHORT' else
if self.val = UInt32($1405) then Result := 'UNSIGNED_INT' else
Result := self.val.ToString;
end;
end;
{$endregion SUN}
{$endregion Перечисления}
{$region Делегаты} type
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
GLDEBUGPROC = procedure(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; message_text: IntPtr; userParam: pointer);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
GLVULKANPROCNV = procedure;
{$endregion Делегаты}
{$region Записи} type
{$region Vec}
{$region Vec1}
Vec1b = record
public val0: SByte;
public constructor(val0: SByte);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1b): Vec1b := new Vec1b(-v.val0);
public static function operator+(v: Vec1b): Vec1b := v;
public static function operator*(v: Vec1b; k: SByte): Vec1b := new Vec1b(v.val0*k);
public static function operator div(v: Vec1b; k: SByte): Vec1b := new Vec1b(v.val0 div k);
public static function operator*(v1, v2: Vec1b): SByte := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1b): Vec1b := new Vec1b(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1b): Vec1b := new Vec1b(v1.val0-v2.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1b;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1ub = record
public val0: Byte;
public constructor(val0: Byte);
begin
self.val0 := val0;
end;
public static function operator+(v: Vec1ub): Vec1ub := v;
public static function operator*(v: Vec1ub; k: Byte): Vec1ub := new Vec1ub(v.val0*k);
public static function operator div(v: Vec1ub; k: Byte): Vec1ub := new Vec1ub(v.val0 div k);
public static function operator*(v1, v2: Vec1ub): Byte := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1ub): Vec1ub := new Vec1ub(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1ub): Vec1ub := new Vec1ub(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1ub): Vec1b := new Vec1b(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1ub;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1s = record
public val0: Int16;
public constructor(val0: Int16);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1s): Vec1s := new Vec1s(-v.val0);
public static function operator+(v: Vec1s): Vec1s := v;
public static function operator*(v: Vec1s; k: Int16): Vec1s := new Vec1s(v.val0*k);
public static function operator div(v: Vec1s; k: Int16): Vec1s := new Vec1s(v.val0 div k);
public static function operator*(v1, v2: Vec1s): Int16 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1s): Vec1s := new Vec1s(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1s): Vec1s := new Vec1s(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1s): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1s): Vec1ub := new Vec1ub(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1s;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1us = record
public val0: UInt16;
public constructor(val0: UInt16);
begin
self.val0 := val0;
end;
public static function operator+(v: Vec1us): Vec1us := v;
public static function operator*(v: Vec1us; k: UInt16): Vec1us := new Vec1us(v.val0*k);
public static function operator div(v: Vec1us; k: UInt16): Vec1us := new Vec1us(v.val0 div k);
public static function operator*(v1, v2: Vec1us): UInt16 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1us): Vec1us := new Vec1us(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1us): Vec1us := new Vec1us(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1us): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1us): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1us): Vec1s := new Vec1s(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1us;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1i = record
public val0: Int32;
public constructor(val0: Int32);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1i): Vec1i := new Vec1i(-v.val0);
public static function operator+(v: Vec1i): Vec1i := v;
public static function operator*(v: Vec1i; k: Int32): Vec1i := new Vec1i(v.val0*k);
public static function operator div(v: Vec1i; k: Int32): Vec1i := new Vec1i(v.val0 div k);
public static function operator*(v1, v2: Vec1i): Int32 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1i): Vec1i := new Vec1i(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1i): Vec1i := new Vec1i(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1i): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1i): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1i): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1i): Vec1us := new Vec1us(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1i;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1ui = record
public val0: UInt32;
public constructor(val0: UInt32);
begin
self.val0 := val0;
end;
public static function operator+(v: Vec1ui): Vec1ui := v;
public static function operator*(v: Vec1ui; k: UInt32): Vec1ui := new Vec1ui(v.val0*k);
public static function operator div(v: Vec1ui; k: UInt32): Vec1ui := new Vec1ui(v.val0 div k);
public static function operator*(v1, v2: Vec1ui): UInt32 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1ui): Vec1ui := new Vec1ui(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1ui): Vec1ui := new Vec1ui(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1ui): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1ui): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1ui): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1ui): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1ui): Vec1i := new Vec1i(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1ui;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1i64 = record
public val0: Int64;
public constructor(val0: Int64);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1i64): Vec1i64 := new Vec1i64(-v.val0);
public static function operator+(v: Vec1i64): Vec1i64 := v;
public static function operator*(v: Vec1i64; k: Int64): Vec1i64 := new Vec1i64(v.val0*k);
public static function operator div(v: Vec1i64; k: Int64): Vec1i64 := new Vec1i64(v.val0 div k);
public static function operator*(v1, v2: Vec1i64): Int64 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1i64): Vec1i64 := new Vec1i64(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1i64): Vec1i64 := new Vec1i64(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1i64): Vec1ui := new Vec1ui(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1i64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1ui64 = record
public val0: UInt64;
public constructor(val0: UInt64);
begin
self.val0 := val0;
end;
public static function operator+(v: Vec1ui64): Vec1ui64 := v;
public static function operator*(v: Vec1ui64; k: UInt64): Vec1ui64 := new Vec1ui64(v.val0*k);
public static function operator div(v: Vec1ui64; k: UInt64): Vec1ui64 := new Vec1ui64(v.val0 div k);
public static function operator*(v1, v2: Vec1ui64): UInt64 := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1ui64): Vec1ui64 := new Vec1ui64(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1ui64): Vec1ui64 := new Vec1ui64(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec1i64 := new Vec1i64(v.val0);
public function SqrLength := val0*val0;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1ui64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec1f = record
public val0: single;
public constructor(val0: single);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1f): Vec1f := new Vec1f(-v.val0);
public static function operator+(v: Vec1f): Vec1f := v;
public static function operator*(v: Vec1f; k: single): Vec1f := new Vec1f(v.val0*k);
public static function operator/(v: Vec1f; k: single): Vec1f := new Vec1f(v.val0/k);
public static function operator*(v1, v2: Vec1f): single := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1f): Vec1f := new Vec1f(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1f): Vec1f := new Vec1f(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1f): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public function SqrLength := val0*val0;
public function Normalized := self / single(Sqrt(self.SqrLength));
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1f;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec1fPtrCallbackP = procedure(var ptr: Vec1f);
UseVec1fPtrCallbackF<T> = function(var ptr: Vec1f): T;
Vec1d = record
public val0: double;
public constructor(val0: double);
begin
self.val0 := val0;
end;
public static function operator-(v: Vec1d): Vec1d := new Vec1d(-v.val0);
public static function operator+(v: Vec1d): Vec1d := v;
public static function operator*(v: Vec1d; k: double): Vec1d := new Vec1d(v.val0*k);
public static function operator/(v: Vec1d; k: double): Vec1d := new Vec1d(v.val0/k);
public static function operator*(v1, v2: Vec1d): double := ( v1.val0*v2.val0 );
public static function operator+(v1, v2: Vec1d): Vec1d := new Vec1d(v1.val0+v2.val0);
public static function operator-(v1, v2: Vec1d): Vec1d := new Vec1d(v1.val0-v2.val0);
public static function operator implicit(v: Vec1b): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec1d): Vec1f := new Vec1f(v.val0);
public function SqrLength := val0*val0;
public function Normalized := self / self.SqrLength.Sqrt;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec1d;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec1dPtrCallbackP = procedure(var ptr: Vec1d);
UseVec1dPtrCallbackF<T> = function(var ptr: Vec1d): T;
{$endregion Vec1}
{$region Vec2}
Vec2b = record
public val0: SByte;
public val1: SByte;
public constructor(val0, val1: SByte);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2b): Vec2b := new Vec2b(-v.val0, -v.val1);
public static function operator+(v: Vec2b): Vec2b := v;
public static function operator*(v: Vec2b; k: SByte): Vec2b := new Vec2b(v.val0*k, v.val1*k);
public static function operator div(v: Vec2b; k: SByte): Vec2b := new Vec2b(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2b): SByte := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2b): Vec2b := new Vec2b(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2b): Vec2b := new Vec2b(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2b := new Vec2b(v.val0, 0);
public static function operator implicit(v: Vec2b): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2b := new Vec2b(Convert.ToSByte(v.val0), 0);
public static function operator implicit(v: Vec2b): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2b := new Vec2b(Convert.ToSByte(v.val0), 0);
public static function operator implicit(v: Vec2b): Vec1d := new Vec1d(v.val0);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2b;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2ub = record
public val0: Byte;
public val1: Byte;
public constructor(val0, val1: Byte);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator+(v: Vec2ub): Vec2ub := v;
public static function operator*(v: Vec2ub; k: Byte): Vec2ub := new Vec2ub(v.val0*k, v.val1*k);
public static function operator div(v: Vec2ub; k: Byte): Vec2ub := new Vec2ub(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2ub): Byte := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2ub): Vec2ub := new Vec2ub(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2ub): Vec2ub := new Vec2ub(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2ub := new Vec2ub(v.val0, 0);
public static function operator implicit(v: Vec2ub): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), 0);
public static function operator implicit(v: Vec2ub): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), 0);
public static function operator implicit(v: Vec2ub): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2b := new Vec2b(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2ub;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2s = record
public val0: Int16;
public val1: Int16;
public constructor(val0, val1: Int16);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2s): Vec2s := new Vec2s(-v.val0, -v.val1);
public static function operator+(v: Vec2s): Vec2s := v;
public static function operator*(v: Vec2s; k: Int16): Vec2s := new Vec2s(v.val0*k, v.val1*k);
public static function operator div(v: Vec2s; k: Int16): Vec2s := new Vec2s(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2s): Int16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2s): Vec2s := new Vec2s(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2s): Vec2s := new Vec2s(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2s := new Vec2s(v.val0, 0);
public static function operator implicit(v: Vec2s): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2s := new Vec2s(Convert.ToInt16(v.val0), 0);
public static function operator implicit(v: Vec2s): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2s := new Vec2s(Convert.ToInt16(v.val0), 0);
public static function operator implicit(v: Vec2s): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2ub := new Vec2ub(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2s;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2us = record
public val0: UInt16;
public val1: UInt16;
public constructor(val0, val1: UInt16);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator+(v: Vec2us): Vec2us := v;
public static function operator*(v: Vec2us; k: UInt16): Vec2us := new Vec2us(v.val0*k, v.val1*k);
public static function operator div(v: Vec2us; k: UInt16): Vec2us := new Vec2us(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2us): UInt16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2us): Vec2us := new Vec2us(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2us): Vec2us := new Vec2us(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2us := new Vec2us(v.val0, 0);
public static function operator implicit(v: Vec2us): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), 0);
public static function operator implicit(v: Vec2us): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), 0);
public static function operator implicit(v: Vec2us): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2s := new Vec2s(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2us;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2i = record
public val0: Int32;
public val1: Int32;
public constructor(val0, val1: Int32);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2i): Vec2i := new Vec2i(-v.val0, -v.val1);
public static function operator+(v: Vec2i): Vec2i := v;
public static function operator*(v: Vec2i; k: Int32): Vec2i := new Vec2i(v.val0*k, v.val1*k);
public static function operator div(v: Vec2i; k: Int32): Vec2i := new Vec2i(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2i): Int32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2i): Vec2i := new Vec2i(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2i): Vec2i := new Vec2i(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2i := new Vec2i(v.val0, 0);
public static function operator implicit(v: Vec2i): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2i := new Vec2i(Convert.ToInt32(v.val0), 0);
public static function operator implicit(v: Vec2i): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2i := new Vec2i(Convert.ToInt32(v.val0), 0);
public static function operator implicit(v: Vec2i): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2us := new Vec2us(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2i;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2ui = record
public val0: UInt32;
public val1: UInt32;
public constructor(val0, val1: UInt32);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator+(v: Vec2ui): Vec2ui := v;
public static function operator*(v: Vec2ui; k: UInt32): Vec2ui := new Vec2ui(v.val0*k, v.val1*k);
public static function operator div(v: Vec2ui; k: UInt32): Vec2ui := new Vec2ui(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2ui): UInt32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2ui): Vec2ui := new Vec2ui(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2ui): Vec2ui := new Vec2ui(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2ui := new Vec2ui(v.val0, 0);
public static function operator implicit(v: Vec2ui): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), 0);
public static function operator implicit(v: Vec2ui): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), 0);
public static function operator implicit(v: Vec2ui): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2i := new Vec2i(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2ui;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2i64 = record
public val0: Int64;
public val1: Int64;
public constructor(val0, val1: Int64);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2i64): Vec2i64 := new Vec2i64(-v.val0, -v.val1);
public static function operator+(v: Vec2i64): Vec2i64 := v;
public static function operator*(v: Vec2i64; k: Int64): Vec2i64 := new Vec2i64(v.val0*k, v.val1*k);
public static function operator div(v: Vec2i64; k: Int64): Vec2i64 := new Vec2i64(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2i64): Int64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2i64): Vec2i64 := new Vec2i64(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2i64): Vec2i64 := new Vec2i64(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2i64 := new Vec2i64(v.val0, 0);
public static function operator implicit(v: Vec2i64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), 0);
public static function operator implicit(v: Vec2i64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), 0);
public static function operator implicit(v: Vec2i64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2ui := new Vec2ui(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2i64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2ui64 = record
public val0: UInt64;
public val1: UInt64;
public constructor(val0, val1: UInt64);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator+(v: Vec2ui64): Vec2ui64 := v;
public static function operator*(v: Vec2ui64; k: UInt64): Vec2ui64 := new Vec2ui64(v.val0*k, v.val1*k);
public static function operator div(v: Vec2ui64; k: UInt64): Vec2ui64 := new Vec2ui64(v.val0 div k, v.val1 div k);
public static function operator*(v1, v2: Vec2ui64): UInt64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2ui64): Vec2ui64 := new Vec2ui64(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2ui64): Vec2ui64 := new Vec2ui64(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec2ui64 := new Vec2ui64(v.val0, 0);
public static function operator implicit(v: Vec2ui64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), 0);
public static function operator implicit(v: Vec2ui64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), 0);
public static function operator implicit(v: Vec2ui64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec2i64 := new Vec2i64(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2ui64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec2f = record
public val0: single;
public val1: single;
public constructor(val0, val1: single);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2f): Vec2f := new Vec2f(-v.val0, -v.val1);
public static function operator+(v: Vec2f): Vec2f := v;
public static function operator*(v: Vec2f; k: single): Vec2f := new Vec2f(v.val0*k, v.val1*k);
public static function operator/(v: Vec2f; k: single): Vec2f := new Vec2f(v.val0/k, v.val1/k);
public static function operator*(v1, v2: Vec2f): single := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2f): Vec2f := new Vec2f(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2f): Vec2f := new Vec2f(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2f := new Vec2f(v.val0, 0);
public static function operator implicit(v: Vec2f): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public function SqrLength := val0*val0 + val1*val1;
public function Normalized := self / single(Sqrt(self.SqrLength));
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2f;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec2fPtrCallbackP = procedure(var ptr: Vec2f);
UseVec2fPtrCallbackF<T> = function(var ptr: Vec2f): T;
Vec2d = record
public val0: double;
public val1: double;
public constructor(val0, val1: double);
begin
self.val0 := val0;
self.val1 := val1;
end;
public static function operator-(v: Vec2d): Vec2d := new Vec2d(-v.val0, -v.val1);
public static function operator+(v: Vec2d): Vec2d := v;
public static function operator*(v: Vec2d; k: double): Vec2d := new Vec2d(v.val0*k, v.val1*k);
public static function operator/(v: Vec2d; k: double): Vec2d := new Vec2d(v.val0/k, v.val1/k);
public static function operator*(v1, v2: Vec2d): double := ( v1.val0*v2.val0 + v1.val1*v2.val1 );
public static function operator+(v1, v2: Vec2d): Vec2d := new Vec2d(v1.val0+v2.val0, v1.val1+v2.val1);
public static function operator-(v1, v2: Vec2d): Vec2d := new Vec2d(v1.val0-v2.val0, v1.val1-v2.val1);
public static function operator implicit(v: Vec1b): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec2d := new Vec2d(v.val0, 0);
public static function operator implicit(v: Vec2d): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public static function operator implicit(v: Vec2f): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec2f := new Vec2f(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1;
public function Normalized := self / self.SqrLength.Sqrt;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec2d;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec2dPtrCallbackP = procedure(var ptr: Vec2d);
UseVec2dPtrCallbackF<T> = function(var ptr: Vec2d): T;
{$endregion Vec2}
{$region Vec3}
Vec3b = record
public val0: SByte;
public val1: SByte;
public val2: SByte;
public constructor(val0, val1, val2: SByte);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3b): Vec3b := new Vec3b(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3b): Vec3b := v;
public static function operator*(v: Vec3b; k: SByte): Vec3b := new Vec3b(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3b; k: SByte): Vec3b := new Vec3b(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3b): SByte := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3b): Vec3b := new Vec3b(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3b): Vec3b := new Vec3b(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3b := new Vec3b(v.val0, 0, 0);
public static function operator implicit(v: Vec3b): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3b := new Vec3b(Convert.ToSByte(v.val0), 0, 0);
public static function operator implicit(v: Vec3b): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3b := new Vec3b(Convert.ToSByte(v.val0), 0, 0);
public static function operator implicit(v: Vec3b): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3b := new Vec3b(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3b): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), 0);
public static function operator implicit(v: Vec3b): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), 0);
public static function operator implicit(v: Vec3b): Vec2d := new Vec2d(v.val0, v.val1);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public static function CrossCW(v1,v2: Vec3b) :=
new Vec3b(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3b) :=
new Vec3b(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3b;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3ub = record
public val0: Byte;
public val1: Byte;
public val2: Byte;
public constructor(val0, val1, val2: Byte);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator+(v: Vec3ub): Vec3ub := v;
public static function operator*(v: Vec3ub; k: Byte): Vec3ub := new Vec3ub(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3ub; k: Byte): Vec3ub := new Vec3ub(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3ub): Byte := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3ub): Vec3ub := new Vec3ub(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3ub): Vec3ub := new Vec3ub(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3ub := new Vec3ub(v.val0, 0, 0);
public static function operator implicit(v: Vec3ub): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), 0, 0);
public static function operator implicit(v: Vec3ub): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), 0, 0);
public static function operator implicit(v: Vec3ub): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3ub := new Vec3ub(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ub): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), 0);
public static function operator implicit(v: Vec3ub): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), 0);
public static function operator implicit(v: Vec3ub): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3ub;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3s = record
public val0: Int16;
public val1: Int16;
public val2: Int16;
public constructor(val0, val1, val2: Int16);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3s): Vec3s := new Vec3s(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3s): Vec3s := v;
public static function operator*(v: Vec3s; k: Int16): Vec3s := new Vec3s(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3s; k: Int16): Vec3s := new Vec3s(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3s): Int16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3s): Vec3s := new Vec3s(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3s): Vec3s := new Vec3s(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3s := new Vec3s(v.val0, 0, 0);
public static function operator implicit(v: Vec3s): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3s := new Vec3s(Convert.ToInt16(v.val0), 0, 0);
public static function operator implicit(v: Vec3s): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3s := new Vec3s(Convert.ToInt16(v.val0), 0, 0);
public static function operator implicit(v: Vec3s): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3s := new Vec3s(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3s): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), 0);
public static function operator implicit(v: Vec3s): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), 0);
public static function operator implicit(v: Vec3s): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public static function CrossCW(v1,v2: Vec3s) :=
new Vec3s(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3s) :=
new Vec3s(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3s;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3us = record
public val0: UInt16;
public val1: UInt16;
public val2: UInt16;
public constructor(val0, val1, val2: UInt16);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator+(v: Vec3us): Vec3us := v;
public static function operator*(v: Vec3us; k: UInt16): Vec3us := new Vec3us(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3us; k: UInt16): Vec3us := new Vec3us(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3us): UInt16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3us): Vec3us := new Vec3us(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3us): Vec3us := new Vec3us(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3us := new Vec3us(v.val0, 0, 0);
public static function operator implicit(v: Vec3us): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), 0, 0);
public static function operator implicit(v: Vec3us): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), 0, 0);
public static function operator implicit(v: Vec3us): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3us := new Vec3us(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3us): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), 0);
public static function operator implicit(v: Vec3us): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), 0);
public static function operator implicit(v: Vec3us): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3us;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3i = record
public val0: Int32;
public val1: Int32;
public val2: Int32;
public constructor(val0, val1, val2: Int32);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3i): Vec3i := new Vec3i(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3i): Vec3i := v;
public static function operator*(v: Vec3i; k: Int32): Vec3i := new Vec3i(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3i; k: Int32): Vec3i := new Vec3i(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3i): Int32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3i): Vec3i := new Vec3i(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3i): Vec3i := new Vec3i(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3i := new Vec3i(v.val0, 0, 0);
public static function operator implicit(v: Vec3i): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3i := new Vec3i(Convert.ToInt32(v.val0), 0, 0);
public static function operator implicit(v: Vec3i): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3i := new Vec3i(Convert.ToInt32(v.val0), 0, 0);
public static function operator implicit(v: Vec3i): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3i := new Vec3i(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), 0);
public static function operator implicit(v: Vec3i): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), 0);
public static function operator implicit(v: Vec3i): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public static function CrossCW(v1,v2: Vec3i) :=
new Vec3i(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3i) :=
new Vec3i(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3i;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3ui = record
public val0: UInt32;
public val1: UInt32;
public val2: UInt32;
public constructor(val0, val1, val2: UInt32);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator+(v: Vec3ui): Vec3ui := v;
public static function operator*(v: Vec3ui; k: UInt32): Vec3ui := new Vec3ui(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3ui; k: UInt32): Vec3ui := new Vec3ui(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3ui): UInt32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3ui): Vec3ui := new Vec3ui(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3ui): Vec3ui := new Vec3ui(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3ui := new Vec3ui(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), 0, 0);
public static function operator implicit(v: Vec3ui): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), 0, 0);
public static function operator implicit(v: Vec3ui): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3ui := new Vec3ui(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), 0);
public static function operator implicit(v: Vec3ui): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), 0);
public static function operator implicit(v: Vec3ui): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3ui;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3i64 = record
public val0: Int64;
public val1: Int64;
public val2: Int64;
public constructor(val0, val1, val2: Int64);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3i64): Vec3i64 := new Vec3i64(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3i64): Vec3i64 := v;
public static function operator*(v: Vec3i64; k: Int64): Vec3i64 := new Vec3i64(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3i64; k: Int64): Vec3i64 := new Vec3i64(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3i64): Int64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3i64): Vec3i64 := new Vec3i64(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3i64): Vec3i64 := new Vec3i64(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3i64 := new Vec3i64(v.val0, 0, 0);
public static function operator implicit(v: Vec3i64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), 0, 0);
public static function operator implicit(v: Vec3i64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), 0, 0);
public static function operator implicit(v: Vec3i64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3i64 := new Vec3i64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3i64): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), 0);
public static function operator implicit(v: Vec3i64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), 0);
public static function operator implicit(v: Vec3i64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public static function CrossCW(v1,v2: Vec3i64) :=
new Vec3i64(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3i64) :=
new Vec3i64(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3i64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3ui64 = record
public val0: UInt64;
public val1: UInt64;
public val2: UInt64;
public constructor(val0, val1, val2: UInt64);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator+(v: Vec3ui64): Vec3ui64 := v;
public static function operator*(v: Vec3ui64; k: UInt64): Vec3ui64 := new Vec3ui64(v.val0*k, v.val1*k, v.val2*k);
public static function operator div(v: Vec3ui64; k: UInt64): Vec3ui64 := new Vec3ui64(v.val0 div k, v.val1 div k, v.val2 div k);
public static function operator*(v1, v2: Vec3ui64): UInt64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3ui64): Vec3ui64 := new Vec3ui64(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3ui64): Vec3ui64 := new Vec3ui64(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec3ui64 := new Vec3ui64(v.val0, 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), 0, 0);
public static function operator implicit(v: Vec3ui64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec3ui64 := new Vec3ui64(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3ui64): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), 0);
public static function operator implicit(v: Vec3ui64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), 0);
public static function operator implicit(v: Vec3ui64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3ui64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec3f = record
public val0: single;
public val1: single;
public val2: single;
public constructor(val0, val1, val2: single);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3f): Vec3f := new Vec3f(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3f): Vec3f := v;
public static function operator*(v: Vec3f; k: single): Vec3f := new Vec3f(v.val0*k, v.val1*k, v.val2*k);
public static function operator/(v: Vec3f; k: single): Vec3f := new Vec3f(v.val0/k, v.val1/k, v.val2/k);
public static function operator*(v1, v2: Vec3f): single := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3f): Vec3f := new Vec3f(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3f): Vec3f := new Vec3f(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3f := new Vec3f(v.val0, 0, 0);
public static function operator implicit(v: Vec3f): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public static function operator implicit(v: Vec2f): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3f := new Vec3f(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3f): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2));
public static function operator implicit(v: Vec3ub): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2));
public static function operator implicit(v: Vec3s): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2));
public static function operator implicit(v: Vec3us): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2));
public static function operator implicit(v: Vec3i): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2));
public static function operator implicit(v: Vec3ui): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2));
public static function operator implicit(v: Vec3i64): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2));
public static function operator implicit(v: Vec3ui64): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2));
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function Normalized := self / single(Sqrt(self.SqrLength));
public static function CrossCW(v1,v2: Vec3f) :=
new Vec3f(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3f) :=
new Vec3f(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3f;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec3fPtrCallbackP = procedure(var ptr: Vec3f);
UseVec3fPtrCallbackF<T> = function(var ptr: Vec3f): T;
Vec3d = record
public val0: double;
public val1: double;
public val2: double;
public constructor(val0, val1, val2: double);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
end;
public static function operator-(v: Vec3d): Vec3d := new Vec3d(-v.val0, -v.val1, -v.val2);
public static function operator+(v: Vec3d): Vec3d := v;
public static function operator*(v: Vec3d; k: double): Vec3d := new Vec3d(v.val0*k, v.val1*k, v.val2*k);
public static function operator/(v: Vec3d; k: double): Vec3d := new Vec3d(v.val0/k, v.val1/k, v.val2/k);
public static function operator*(v1, v2: Vec3d): double := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 );
public static function operator+(v1, v2: Vec3d): Vec3d := new Vec3d(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2);
public static function operator-(v1, v2: Vec3d): Vec3d := new Vec3d(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2);
public static function operator implicit(v: Vec1b): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec3d := new Vec3d(v.val0, 0, 0);
public static function operator implicit(v: Vec3d): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public static function operator implicit(v: Vec2f): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec3d := new Vec3d(v.val0, v.val1, 0);
public static function operator implicit(v: Vec3d): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2));
public static function operator implicit(v: Vec3ub): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2));
public static function operator implicit(v: Vec3s): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2));
public static function operator implicit(v: Vec3us): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2));
public static function operator implicit(v: Vec3i): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2));
public static function operator implicit(v: Vec3ui): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2));
public static function operator implicit(v: Vec3i64): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2));
public static function operator implicit(v: Vec3ui64): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2));
public static function operator implicit(v: Vec3f): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2;
public function Normalized := self / self.SqrLength.Sqrt;
public static function CrossCW(v1,v2: Vec3d) :=
new Vec3d(v1.val2*v2.val1 - v2.val2*v1.val1, v1.val0*v2.val2 - v2.val0*v1.val2, v1.val1*v2.val0 - v2.val1*v1.val0);
public static function CrossCCW(v1,v2: Vec3d) :=
new Vec3d(v1.val1*v2.val2 - v2.val1*v1.val2, v1.val2*v2.val0 - v2.val2*v1.val0, v1.val0*v2.val1 - v2.val0*v1.val1);
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec3d;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec3dPtrCallbackP = procedure(var ptr: Vec3d);
UseVec3dPtrCallbackF<T> = function(var ptr: Vec3d): T;
{$endregion Vec3}
{$region Vec4}
Vec4b = record
public val0: SByte;
public val1: SByte;
public val2: SByte;
public val3: SByte;
public constructor(val0, val1, val2, val3: SByte);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4b): Vec4b := new Vec4b(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4b): Vec4b := v;
public static function operator*(v: Vec4b; k: SByte): Vec4b := new Vec4b(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4b; k: SByte): Vec4b := new Vec4b(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4b): SByte := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4b): Vec4b := new Vec4b(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4b): Vec4b := new Vec4b(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4b := new Vec4b(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4b := new Vec4b(Convert.ToSByte(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4b := new Vec4b(Convert.ToSByte(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4b): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4b := new Vec4b(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4b): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), 0, 0);
public static function operator implicit(v: Vec4b): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), 0, 0);
public static function operator implicit(v: Vec4b): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4b := new Vec4b(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4b): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2), 0);
public static function operator implicit(v: Vec4b): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2), 0);
public static function operator implicit(v: Vec4b): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4b;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4ub = record
public val0: Byte;
public val1: Byte;
public val2: Byte;
public val3: Byte;
public constructor(val0, val1, val2, val3: Byte);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator+(v: Vec4ub): Vec4ub := v;
public static function operator*(v: Vec4ub; k: Byte): Vec4ub := new Vec4ub(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4ub; k: Byte): Vec4ub := new Vec4ub(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4ub): Byte := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4ub): Vec4ub := new Vec4ub(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4ub): Vec4ub := new Vec4ub(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4ub := new Vec4ub(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ub): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4ub := new Vec4ub(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ub): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), 0, 0);
public static function operator implicit(v: Vec4ub): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), 0, 0);
public static function operator implicit(v: Vec4ub): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ub): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2), 0);
public static function operator implicit(v: Vec4ub): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2), 0);
public static function operator implicit(v: Vec4ub): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4ub;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4s = record
public val0: Int16;
public val1: Int16;
public val2: Int16;
public val3: Int16;
public constructor(val0, val1, val2, val3: Int16);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4s): Vec4s := new Vec4s(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4s): Vec4s := v;
public static function operator*(v: Vec4s; k: Int16): Vec4s := new Vec4s(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4s; k: Int16): Vec4s := new Vec4s(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4s): Int16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4s): Vec4s := new Vec4s(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4s): Vec4s := new Vec4s(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4s := new Vec4s(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4s := new Vec4s(Convert.ToInt16(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4s := new Vec4s(Convert.ToInt16(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4s): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4s := new Vec4s(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4s): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), 0, 0);
public static function operator implicit(v: Vec4s): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), 0, 0);
public static function operator implicit(v: Vec4s): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4s := new Vec4s(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4s): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2), 0);
public static function operator implicit(v: Vec4s): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2), 0);
public static function operator implicit(v: Vec4s): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4s;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4us = record
public val0: UInt16;
public val1: UInt16;
public val2: UInt16;
public val3: UInt16;
public constructor(val0, val1, val2, val3: UInt16);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator+(v: Vec4us): Vec4us := v;
public static function operator*(v: Vec4us; k: UInt16): Vec4us := new Vec4us(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4us; k: UInt16): Vec4us := new Vec4us(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4us): UInt16 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4us): Vec4us := new Vec4us(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4us): Vec4us := new Vec4us(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4us := new Vec4us(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4us): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4us := new Vec4us(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4us): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), 0, 0);
public static function operator implicit(v: Vec4us): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), 0, 0);
public static function operator implicit(v: Vec4us): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4us := new Vec4us(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4us): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2), 0);
public static function operator implicit(v: Vec4us): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2), 0);
public static function operator implicit(v: Vec4us): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4us;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4i = record
public val0: Int32;
public val1: Int32;
public val2: Int32;
public val3: Int32;
public constructor(val0, val1, val2, val3: Int32);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4i): Vec4i := new Vec4i(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4i): Vec4i := v;
public static function operator*(v: Vec4i; k: Int32): Vec4i := new Vec4i(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4i; k: Int32): Vec4i := new Vec4i(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4i): Int32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4i): Vec4i := new Vec4i(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4i): Vec4i := new Vec4i(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4i := new Vec4i(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4i := new Vec4i(Convert.ToInt32(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4i := new Vec4i(Convert.ToInt32(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4i): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4i := new Vec4i(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), 0, 0);
public static function operator implicit(v: Vec4i): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), 0, 0);
public static function operator implicit(v: Vec4i): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4i := new Vec4i(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2), 0);
public static function operator implicit(v: Vec4i): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2), 0);
public static function operator implicit(v: Vec4i): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4i;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4ui = record
public val0: UInt32;
public val1: UInt32;
public val2: UInt32;
public val3: UInt32;
public constructor(val0, val1, val2, val3: UInt32);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator+(v: Vec4ui): Vec4ui := v;
public static function operator*(v: Vec4ui; k: UInt32): Vec4ui := new Vec4ui(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4ui; k: UInt32): Vec4ui := new Vec4ui(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4ui): UInt32 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4ui): Vec4ui := new Vec4ui(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4ui): Vec4ui := new Vec4ui(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4ui := new Vec4ui(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ui): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4ui := new Vec4ui(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), 0, 0);
public static function operator implicit(v: Vec4ui): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), 0, 0);
public static function operator implicit(v: Vec4ui): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2), 0);
public static function operator implicit(v: Vec4ui): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2), 0);
public static function operator implicit(v: Vec4ui): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4ui;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4i64 = record
public val0: Int64;
public val1: Int64;
public val2: Int64;
public val3: Int64;
public constructor(val0, val1, val2, val3: Int64);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4i64): Vec4i64 := new Vec4i64(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4i64): Vec4i64 := v;
public static function operator*(v: Vec4i64; k: Int64): Vec4i64 := new Vec4i64(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4i64; k: Int64): Vec4i64 := new Vec4i64(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4i64): Int64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4i64): Vec4i64 := new Vec4i64(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4i64): Vec4i64 := new Vec4i64(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4i64 := new Vec4i64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4i64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4i64 := new Vec4i64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4i64): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), 0, 0);
public static function operator implicit(v: Vec4i64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), 0, 0);
public static function operator implicit(v: Vec4i64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4i64): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2), 0);
public static function operator implicit(v: Vec4i64): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2), 0);
public static function operator implicit(v: Vec4i64): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4i64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4ui64 = record
public val0: UInt64;
public val1: UInt64;
public val2: UInt64;
public val3: UInt64;
public constructor(val0, val1, val2, val3: UInt64);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator+(v: Vec4ui64): Vec4ui64 := v;
public static function operator*(v: Vec4ui64; k: UInt64): Vec4ui64 := new Vec4ui64(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator div(v: Vec4ui64; k: UInt64): Vec4ui64 := new Vec4ui64(v.val0 div k, v.val1 div k, v.val2 div k, v.val3 div k);
public static function operator*(v1, v2: Vec4ui64): UInt64 := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4ui64): Vec4ui64 := new Vec4ui64(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4ui64): Vec4ui64 := new Vec4ui64(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1b := new Vec1b(v.val0);
public static function operator implicit(v: Vec1ub): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1ub := new Vec1ub(v.val0);
public static function operator implicit(v: Vec1s): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1s := new Vec1s(v.val0);
public static function operator implicit(v: Vec1us): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1us := new Vec1us(v.val0);
public static function operator implicit(v: Vec1i): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1i := new Vec1i(v.val0);
public static function operator implicit(v: Vec1ui): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1ui := new Vec1ui(v.val0);
public static function operator implicit(v: Vec1i64): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1i64 := new Vec1i64(v.val0);
public static function operator implicit(v: Vec1ui64): Vec4ui64 := new Vec4ui64(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1ui64 := new Vec1ui64(v.val0);
public static function operator implicit(v: Vec1f): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), 0, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2b := new Vec2b(v.val0, v.val1);
public static function operator implicit(v: Vec2ub): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2ub := new Vec2ub(v.val0, v.val1);
public static function operator implicit(v: Vec2s): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2s := new Vec2s(v.val0, v.val1);
public static function operator implicit(v: Vec2us): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2us := new Vec2us(v.val0, v.val1);
public static function operator implicit(v: Vec2i): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2i := new Vec2i(v.val0, v.val1);
public static function operator implicit(v: Vec2ui): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2ui := new Vec2ui(v.val0, v.val1);
public static function operator implicit(v: Vec2i64): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2i64 := new Vec2i64(v.val0, v.val1);
public static function operator implicit(v: Vec2ui64): Vec4ui64 := new Vec4ui64(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2ui64 := new Vec2ui64(v.val0, v.val1);
public static function operator implicit(v: Vec2f): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), 0, 0);
public static function operator implicit(v: Vec4ui64): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3b := new Vec3b(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ub): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3ub := new Vec3ub(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3s): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3s := new Vec3s(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3us): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3us := new Vec3us(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3i := new Vec3i(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3ui := new Vec3ui(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3i64): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3i64 := new Vec3i64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3ui64): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4ui64): Vec3ui64 := new Vec3ui64(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3f): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2), 0);
public static function operator implicit(v: Vec4ui64): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2), 0);
public static function operator implicit(v: Vec4ui64): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4b := new Vec4b(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ub): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4ub := new Vec4ub(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4s): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4s := new Vec4s(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4us): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4us := new Vec4us(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4i := new Vec4i(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4ui := new Vec4ui(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4i64): Vec4ui64 := new Vec4ui64(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4ui64): Vec4i64 := new Vec4i64(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4ui64;
begin
Writeln(self.ToString);
Result := self;
end;
end;
Vec4f = record
public val0: single;
public val1: single;
public val2: single;
public val3: single;
public constructor(val0, val1, val2, val3: single);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4f): Vec4f := new Vec4f(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4f): Vec4f := v;
public static function operator*(v: Vec4f; k: single): Vec4f := new Vec4f(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator/(v: Vec4f; k: single): Vec4f := new Vec4f(v.val0/k, v.val1/k, v.val2/k, v.val3/k);
public static function operator*(v1, v2: Vec4f): single := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4f): Vec4f := new Vec4f(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4f): Vec4f := new Vec4f(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4f := new Vec4f(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4f): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public static function operator implicit(v: Vec2f): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4f := new Vec4f(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4f): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2));
public static function operator implicit(v: Vec3ub): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2));
public static function operator implicit(v: Vec3s): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2));
public static function operator implicit(v: Vec3us): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2));
public static function operator implicit(v: Vec3i): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2));
public static function operator implicit(v: Vec3ui): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2));
public static function operator implicit(v: Vec3i64): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2));
public static function operator implicit(v: Vec3ui64): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2));
public static function operator implicit(v: Vec3f): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4f := new Vec4f(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4f): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2), Convert.ToSByte(v.val3));
public static function operator implicit(v: Vec4ub): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2), Convert.ToByte(v.val3));
public static function operator implicit(v: Vec4s): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2), Convert.ToInt16(v.val3));
public static function operator implicit(v: Vec4us): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2), Convert.ToUInt16(v.val3));
public static function operator implicit(v: Vec4i): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2), Convert.ToInt32(v.val3));
public static function operator implicit(v: Vec4ui): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2), Convert.ToUInt32(v.val3));
public static function operator implicit(v: Vec4i64): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2), Convert.ToInt64(v.val3));
public static function operator implicit(v: Vec4ui64): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4f): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2), Convert.ToUInt64(v.val3));
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function Normalized := self / single(Sqrt(self.SqrLength));
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4f;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec4fPtrCallbackP = procedure(var ptr: Vec4f);
UseVec4fPtrCallbackF<T> = function(var ptr: Vec4f): T;
Vec4d = record
public val0: double;
public val1: double;
public val2: double;
public val3: double;
public constructor(val0, val1, val2, val3: double);
begin
self.val0 := val0;
self.val1 := val1;
self.val2 := val2;
self.val3 := val3;
end;
public static function operator-(v: Vec4d): Vec4d := new Vec4d(-v.val0, -v.val1, -v.val2, -v.val3);
public static function operator+(v: Vec4d): Vec4d := v;
public static function operator*(v: Vec4d; k: double): Vec4d := new Vec4d(v.val0*k, v.val1*k, v.val2*k, v.val3*k);
public static function operator/(v: Vec4d; k: double): Vec4d := new Vec4d(v.val0/k, v.val1/k, v.val2/k, v.val3/k);
public static function operator*(v1, v2: Vec4d): double := ( v1.val0*v2.val0 + v1.val1*v2.val1 + v1.val2*v2.val2 + v1.val3*v2.val3 );
public static function operator+(v1, v2: Vec4d): Vec4d := new Vec4d(v1.val0+v2.val0, v1.val1+v2.val1, v1.val2+v2.val2, v1.val3+v2.val3);
public static function operator-(v1, v2: Vec4d): Vec4d := new Vec4d(v1.val0-v2.val0, v1.val1-v2.val1, v1.val2-v2.val2, v1.val3-v2.val3);
public static function operator implicit(v: Vec1b): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1b := new Vec1b(Convert.ToSByte(v.val0));
public static function operator implicit(v: Vec1ub): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1ub := new Vec1ub(Convert.ToByte(v.val0));
public static function operator implicit(v: Vec1s): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1s := new Vec1s(Convert.ToInt16(v.val0));
public static function operator implicit(v: Vec1us): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1us := new Vec1us(Convert.ToUInt16(v.val0));
public static function operator implicit(v: Vec1i): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1i := new Vec1i(Convert.ToInt32(v.val0));
public static function operator implicit(v: Vec1ui): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1ui := new Vec1ui(Convert.ToUInt32(v.val0));
public static function operator implicit(v: Vec1i64): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1i64 := new Vec1i64(Convert.ToInt64(v.val0));
public static function operator implicit(v: Vec1ui64): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1ui64 := new Vec1ui64(Convert.ToUInt64(v.val0));
public static function operator implicit(v: Vec1f): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1f := new Vec1f(v.val0);
public static function operator implicit(v: Vec1d): Vec4d := new Vec4d(v.val0, 0, 0, 0);
public static function operator implicit(v: Vec4d): Vec1d := new Vec1d(v.val0);
public static function operator implicit(v: Vec2b): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2b := new Vec2b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1));
public static function operator implicit(v: Vec2ub): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2ub := new Vec2ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1));
public static function operator implicit(v: Vec2s): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2s := new Vec2s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1));
public static function operator implicit(v: Vec2us): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2us := new Vec2us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1));
public static function operator implicit(v: Vec2i): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2i := new Vec2i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1));
public static function operator implicit(v: Vec2ui): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2ui := new Vec2ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1));
public static function operator implicit(v: Vec2i64): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2i64 := new Vec2i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1));
public static function operator implicit(v: Vec2ui64): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2ui64 := new Vec2ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1));
public static function operator implicit(v: Vec2f): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2f := new Vec2f(v.val0, v.val1);
public static function operator implicit(v: Vec2d): Vec4d := new Vec4d(v.val0, v.val1, 0, 0);
public static function operator implicit(v: Vec4d): Vec2d := new Vec2d(v.val0, v.val1);
public static function operator implicit(v: Vec3b): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3b := new Vec3b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2));
public static function operator implicit(v: Vec3ub): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3ub := new Vec3ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2));
public static function operator implicit(v: Vec3s): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3s := new Vec3s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2));
public static function operator implicit(v: Vec3us): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3us := new Vec3us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2));
public static function operator implicit(v: Vec3i): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3i := new Vec3i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2));
public static function operator implicit(v: Vec3ui): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3ui := new Vec3ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2));
public static function operator implicit(v: Vec3i64): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3i64 := new Vec3i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2));
public static function operator implicit(v: Vec3ui64): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3ui64 := new Vec3ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2));
public static function operator implicit(v: Vec3f): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3f := new Vec3f(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec3d): Vec4d := new Vec4d(v.val0, v.val1, v.val2, 0);
public static function operator implicit(v: Vec4d): Vec3d := new Vec3d(v.val0, v.val1, v.val2);
public static function operator implicit(v: Vec4b): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4b := new Vec4b(Convert.ToSByte(v.val0), Convert.ToSByte(v.val1), Convert.ToSByte(v.val2), Convert.ToSByte(v.val3));
public static function operator implicit(v: Vec4ub): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4ub := new Vec4ub(Convert.ToByte(v.val0), Convert.ToByte(v.val1), Convert.ToByte(v.val2), Convert.ToByte(v.val3));
public static function operator implicit(v: Vec4s): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4s := new Vec4s(Convert.ToInt16(v.val0), Convert.ToInt16(v.val1), Convert.ToInt16(v.val2), Convert.ToInt16(v.val3));
public static function operator implicit(v: Vec4us): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4us := new Vec4us(Convert.ToUInt16(v.val0), Convert.ToUInt16(v.val1), Convert.ToUInt16(v.val2), Convert.ToUInt16(v.val3));
public static function operator implicit(v: Vec4i): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4i := new Vec4i(Convert.ToInt32(v.val0), Convert.ToInt32(v.val1), Convert.ToInt32(v.val2), Convert.ToInt32(v.val3));
public static function operator implicit(v: Vec4ui): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4ui := new Vec4ui(Convert.ToUInt32(v.val0), Convert.ToUInt32(v.val1), Convert.ToUInt32(v.val2), Convert.ToUInt32(v.val3));
public static function operator implicit(v: Vec4i64): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4i64 := new Vec4i64(Convert.ToInt64(v.val0), Convert.ToInt64(v.val1), Convert.ToInt64(v.val2), Convert.ToInt64(v.val3));
public static function operator implicit(v: Vec4ui64): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4ui64 := new Vec4ui64(Convert.ToUInt64(v.val0), Convert.ToUInt64(v.val1), Convert.ToUInt64(v.val2), Convert.ToUInt64(v.val3));
public static function operator implicit(v: Vec4f): Vec4d := new Vec4d(v.val0, v.val1, v.val2, v.val3);
public static function operator implicit(v: Vec4d): Vec4f := new Vec4f(v.val0, v.val1, v.val2, v.val3);
public function SqrLength := val0*val0 + val1*val1 + val2*val2 + val3*val3;
public function Normalized := self / self.SqrLength.Sqrt;
public function ToString: string; override;
begin
var res := new StringBuilder;
res += '[ ';
res += val0.ToString('f2');
res += ', ';
res += val1.ToString('f2');
res += ', ';
res += val2.ToString('f2');
res += ', ';
res += val3.ToString('f2');
res += ' ]';
Result := res.ToString;
end;
public function Println: Vec4d;
begin
Writeln(self.ToString);
Result := self;
end;
end;
UseVec4dPtrCallbackP = procedure(var ptr: Vec4d);
UseVec4dPtrCallbackF<T> = function(var ptr: Vec4d): T;
{$endregion Vec4}
{$endregion Vec}
{$region Mtr}
Mtr2x2f = record
public val00, val10: single;
public val01, val11: single;
public constructor(val00, val01, val10, val11: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
end;
public static property Identity: Mtr2x2f read new Mtr2x2f(1.0, 0.0, 0.0, 1.0);
public property Row0: Vec2f read new Vec2f(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2f read new Vec2f(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Col0: Vec2f read new Vec2f(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2f read new Vec2f(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property ColPtr0: ^Vec2f read pointer(@val00);
public property ColPtr1: ^Vec2f read pointer(@val01);
public property ColPtr[x: integer]: ^Vec2f read pointer(IntPtr(pointer(@self)) + x*8);
public procedure UseColPtr0(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val01))^); end;
public static function Scale(k: single): Mtr2x2f := new Mtr2x2f(k, 0.0, 0.0, k);
public static function Traslate(X: single): Mtr2x2f := new Mtr2x2f(1.0, X, 0.0, 1.0);
public static function TraslateTransposed(X: single): Mtr2x2f := new Mtr2x2f(1.0, 0.0, X, 1.0);
public static function RotateXYcw(rot: double): Mtr2x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x2f(
cr, +sr,
-sr, cr
);
end;
public static function RotateXYccw(rot: double): Mtr2x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x2f(
cr, -sr,
+sr, cr
);
end;
public function Det: single :=
val00*val11 - val10*val01;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x2f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x2f; v: Vec2f): Vec2f := new Vec2f(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1);
public static function operator*(v: Vec2f; m: Mtr2x2f): Vec2f := new Vec2f(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1);
end;
Mtr2f = Mtr2x2f;
Mtr3x3f = record
public val00, val10, val20: single;
public val01, val11, val21: single;
public val02, val12, val22: single;
public constructor(val00, val01, val02, val10, val11, val12, val20, val21, val22: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
end;
public static property Identity: Mtr3x3f read new Mtr3x3f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
public property Row0: Vec3f read new Vec3f(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3f read new Vec3f(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Row2: Vec3f read new Vec3f(self.val20, self.val21, self.val22) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; end;
public property Col0: Vec3f read new Vec3f(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3f read new Vec3f(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property Col2: Vec3f read new Vec3f(self.val02, self.val12, self.val22) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; end;
public property ColPtr0: ^Vec3f read pointer(@val00);
public property ColPtr1: ^Vec3f read pointer(@val01);
public property ColPtr2: ^Vec3f read pointer(@val02);
public property ColPtr[x: integer]: ^Vec3f read pointer(IntPtr(pointer(@self)) + x*12);
public procedure UseColPtr0(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val02))^); end;
public static function Scale(k: single): Mtr3x3f := new Mtr3x3f(k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, k);
public static function Traslate(X, Y: single): Mtr3x3f := new Mtr3x3f(1.0, 0.0, X, 0.0, 1.0, Y, 0.0, 0.0, 1.0);
public static function TraslateTransposed(X, Y: single): Mtr3x3f := new Mtr3x3f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, X, Y, 1.0);
public static function RotateXYcw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
cr, +sr, 0.0,
-sr, cr, 0.0,
0.0, 0.0, 1.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
cr, -sr, 0.0,
+sr, cr, 0.0,
0.0, 0.0, 1.0
);
end;
public static function RotateYZcw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
1.0, 0.0, 0.0,
0.0, cr, +sr,
0.0, -sr, cr
);
end;
public static function RotateYZccw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
1.0, 0.0, 0.0,
0.0, cr, -sr,
0.0, +sr, cr
);
end;
public static function RotateZXcw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
cr, 0.0, -sr,
0.0, 1.0, 0.0,
+sr, 0.0, cr
);
end;
public static function RotateZXccw(rot: double): Mtr3x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x3f(
cr, 0.0, +sr,
0.0, 1.0, 0.0,
-sr, 0.0, cr
);
end;
public static function Rotate3Dcw(u: Vec3f; rot: double): Mtr3x3f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3f; rot: double): Mtr3x3f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function Det: single :=
val00 * (val11*val22 - val21*val12) - val01 * (val10*val22 - val20*val12) + val02 * (val10*val21 - val20*val11);
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x3f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x3f; v: Vec3f): Vec3f := new Vec3f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2);
public static function operator*(v: Vec3f; m: Mtr3x3f): Vec3f := new Vec3f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr3x3f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
end;
Mtr3f = Mtr3x3f;
Mtr4x4f = record
public val00, val10, val20, val30: single;
public val01, val11, val21, val31: single;
public val02, val12, val22, val32: single;
public val03, val13, val23, val33: single;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13, val20, val21, val22, val23, val30, val31, val32, val33: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val23 := val23;
self.val30 := val30;
self.val31 := val31;
self.val32 := val32;
self.val33 := val33;
end;
public static property Identity: Mtr4x4f read new Mtr4x4f(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public property Row0: Vec4f read new Vec4f(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4f read new Vec4f(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Row2: Vec4f read new Vec4f(self.val20, self.val21, self.val22, self.val23) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; self.val23 := value.val3; end;
public property Row3: Vec4f read new Vec4f(self.val30, self.val31, self.val32, self.val33) write begin self.val30 := value.val0; self.val31 := value.val1; self.val32 := value.val2; self.val33 := value.val3; end;
public property Col0: Vec4f read new Vec4f(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4f read new Vec4f(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property Col2: Vec4f read new Vec4f(self.val02, self.val12, self.val22, self.val32) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; self.val32 := value.val3; end;
public property Col3: Vec4f read new Vec4f(self.val03, self.val13, self.val23, self.val33) write begin self.val03 := value.val0; self.val13 := value.val1; self.val23 := value.val2; self.val33 := value.val3; end;
public property ColPtr0: ^Vec4f read pointer(@val00);
public property ColPtr1: ^Vec4f read pointer(@val01);
public property ColPtr2: ^Vec4f read pointer(@val02);
public property ColPtr3: ^Vec4f read pointer(@val03);
public property ColPtr[x: integer]: ^Vec4f read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val03))^); end;
public static function Scale(k: single): Mtr4x4f := new Mtr4x4f(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k);
public static function Traslate(X, Y, Z: single): Mtr4x4f := new Mtr4x4f(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y, 0.0, 0.0, 1.0, Z, 0.0, 0.0, 0.0, 1.0);
public static function TraslateTransposed(X, Y, Z: single): Mtr4x4f := new Mtr4x4f(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, X, Y, Z, 1.0);
public static function RotateXYcw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateYZcw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
1.0, 0.0, 0.0, 0.0,
0.0, cr, +sr, 0.0,
0.0, -sr, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateYZccw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
1.0, 0.0, 0.0, 0.0,
0.0, cr, -sr, 0.0,
0.0, +sr, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateZXcw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
cr, 0.0, -sr, 0.0,
0.0, 1.0, 0.0, 0.0,
+sr, 0.0, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateZXccw(rot: double): Mtr4x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x4f(
cr, 0.0, +sr, 0.0,
0.0, 1.0, 0.0, 0.0,
-sr, 0.0, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function Rotate3Dcw(u: Vec3f; rot: double): Mtr4x4f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
Result.val33 := 1;
end;
public static function Rotate3Dccw(u: Vec3f; rot: double): Mtr4x4f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
Result.val33 := 1;
end;
public function Det: single :=
val00 * (val11 * (val21*val32 - val31*val22) - val12 * (val22*val33 - val32*val23) + val13 * (val21*val33 - val31*val23)) - val01 * (val10 * (val22*val33 - val32*val23) - val12 * (val20*val32 - val30*val22) + val13 * (val20*val33 - val30*val23)) + val02 * (val10 * (val21*val33 - val31*val23) - val11 * (val20*val33 - val30*val23) + val13 * (val20*val31 - val30*val21)) - val03 * (val10 * (val21*val32 - val31*val22) - val11 * (val20*val32 - val30*val22) + val12 * (val20*val31 - val30*val21));
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[2,3] := (Sign(val23)=-1?'-':'+') + Abs(val23).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
ElStrs[3,2] := (Sign(val32)=-1?'-':'+') + Abs(val32).ToString('f2');
ElStrs[3,3] := (Sign(val33)=-1?'-':'+') + Abs(val33).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x4f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x4f; v: Vec4f): Vec4f := new Vec4f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2+m.val23*v.val3, m.val30*v.val0+m.val31*v.val1+m.val32*v.val2+m.val33*v.val3);
public static function operator*(v: Vec4f; m: Mtr4x4f): Vec4f := new Vec4f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2+m.val32*v.val3, m.val03*v.val0+m.val13*v.val1+m.val23*v.val2+m.val33*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
end;
Mtr4f = Mtr4x4f;
Mtr2x3f = record
public val00, val10: single;
public val01, val11: single;
public val02, val12: single;
public constructor(val00, val01, val02, val10, val11, val12: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
end;
public static property Identity: Mtr2x3f read new Mtr2x3f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public property Row0: Vec3f read new Vec3f(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3f read new Vec3f(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Col0: Vec2f read new Vec2f(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2f read new Vec2f(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property Col2: Vec2f read new Vec2f(self.val02, self.val12) write begin self.val02 := value.val0; self.val12 := value.val1; end;
public property ColPtr0: ^Vec2f read pointer(@val00);
public property ColPtr1: ^Vec2f read pointer(@val01);
public property ColPtr2: ^Vec2f read pointer(@val02);
public property ColPtr[x: integer]: ^Vec2f read pointer(IntPtr(pointer(@self)) + x*8);
public procedure UseColPtr0(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val02))^); end;
public static function Scale(k: single): Mtr2x3f := new Mtr2x3f(k, 0.0, 0.0, 0.0, k, 0.0);
public static function Traslate(X, Y: single): Mtr2x3f := new Mtr2x3f(1.0, 0.0, X, 0.0, 1.0, Y);
public static function TraslateTransposed(X: single): Mtr2x3f := new Mtr2x3f(1.0, 0.0, 0.0, X, 1.0, 0.0);
public static function RotateXYcw(rot: double): Mtr2x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x3f(
cr, +sr, 0.0,
-sr, cr, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr2x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x3f(
cr, -sr, 0.0,
+sr, cr, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x3f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x3f; v: Vec3f): Vec2f := new Vec2f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2);
public static function operator*(v: Vec2f; m: Mtr2x3f): Vec3f := new Vec3f(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1, m.val02*v.val0+m.val12*v.val1);
public static function operator implicit(m: Mtr2x2f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr2x3f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
end;
Mtr3x2f = record
public val00, val10, val20: single;
public val01, val11, val21: single;
public constructor(val00, val01, val10, val11, val20, val21: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
self.val20 := val20;
self.val21 := val21;
end;
public static property Identity: Mtr3x2f read new Mtr3x2f(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
public property Row0: Vec2f read new Vec2f(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2f read new Vec2f(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Row2: Vec2f read new Vec2f(self.val20, self.val21) write begin self.val20 := value.val0; self.val21 := value.val1; end;
public property Col0: Vec3f read new Vec3f(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3f read new Vec3f(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property ColPtr0: ^Vec3f read pointer(@val00);
public property ColPtr1: ^Vec3f read pointer(@val01);
public property ColPtr[x: integer]: ^Vec3f read pointer(IntPtr(pointer(@self)) + x*12);
public procedure UseColPtr0(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val01))^); end;
public static function Scale(k: single): Mtr3x2f := new Mtr3x2f(k, 0.0, 0.0, k, 0.0, 0.0);
public static function Traslate(X: single): Mtr3x2f := new Mtr3x2f(1.0, X, 0.0, 1.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y: single): Mtr3x2f := new Mtr3x2f(1.0, 0.0, 0.0, 1.0, X, Y);
public static function RotateXYcw(rot: double): Mtr3x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x2f(
cr, +sr,
-sr, cr,
0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x2f(
cr, -sr,
+sr, cr,
0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x2f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x2f; v: Vec2f): Vec3f := new Vec3f(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1, m.val20*v.val0+m.val21*v.val1);
public static function operator*(v: Vec3f; m: Mtr3x2f): Vec2f := new Vec2f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
end;
Mtr2x4f = record
public val00, val10: single;
public val01, val11: single;
public val02, val12: single;
public val03, val13: single;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
end;
public static property Identity: Mtr2x4f read new Mtr2x4f(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
public property Row0: Vec4f read new Vec4f(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4f read new Vec4f(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Col0: Vec2f read new Vec2f(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2f read new Vec2f(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property Col2: Vec2f read new Vec2f(self.val02, self.val12) write begin self.val02 := value.val0; self.val12 := value.val1; end;
public property Col3: Vec2f read new Vec2f(self.val03, self.val13) write begin self.val03 := value.val0; self.val13 := value.val1; end;
public property ColPtr0: ^Vec2f read pointer(@val00);
public property ColPtr1: ^Vec2f read pointer(@val01);
public property ColPtr2: ^Vec2f read pointer(@val02);
public property ColPtr3: ^Vec2f read pointer(@val03);
public property ColPtr[x: integer]: ^Vec2f read pointer(IntPtr(pointer(@self)) + x*8);
public procedure UseColPtr0(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec2fPtrCallbackP);
type PVec2f = ^Vec2f;
begin callback(PVec2f(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec2fPtrCallbackF<T>): T;
type PVec2f = ^Vec2f;
begin Result := callback(PVec2f(pointer(@val03))^); end;
public static function Scale(k: single): Mtr2x4f := new Mtr2x4f(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0);
public static function Traslate(X, Y: single): Mtr2x4f := new Mtr2x4f(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y);
public static function TraslateTransposed(X: single): Mtr2x4f := new Mtr2x4f(1.0, 0.0, 0.0, 0.0, X, 1.0, 0.0, 0.0);
public static function RotateXYcw(rot: double): Mtr2x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x4f(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr2x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr2x4f(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x4f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x4f; v: Vec4f): Vec2f := new Vec2f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3);
public static function operator*(v: Vec2f; m: Mtr2x4f): Vec4f := new Vec4f(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1, m.val02*v.val0+m.val12*v.val1, m.val03*v.val0+m.val13*v.val1);
public static function operator implicit(m: Mtr2x2f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr2x4f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
end;
Mtr4x2f = record
public val00, val10, val20, val30: single;
public val01, val11, val21, val31: single;
public constructor(val00, val01, val10, val11, val20, val21, val30, val31: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
self.val20 := val20;
self.val21 := val21;
self.val30 := val30;
self.val31 := val31;
end;
public static property Identity: Mtr4x2f read new Mtr4x2f(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0);
public property Row0: Vec2f read new Vec2f(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2f read new Vec2f(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Row2: Vec2f read new Vec2f(self.val20, self.val21) write begin self.val20 := value.val0; self.val21 := value.val1; end;
public property Row3: Vec2f read new Vec2f(self.val30, self.val31) write begin self.val30 := value.val0; self.val31 := value.val1; end;
public property Col0: Vec4f read new Vec4f(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4f read new Vec4f(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property ColPtr0: ^Vec4f read pointer(@val00);
public property ColPtr1: ^Vec4f read pointer(@val01);
public property ColPtr[x: integer]: ^Vec4f read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val01))^); end;
public static function Scale(k: single): Mtr4x2f := new Mtr4x2f(k, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0);
public static function Traslate(X: single): Mtr4x2f := new Mtr4x2f(1.0, X, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y: single): Mtr4x2f := new Mtr4x2f(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, X, Y);
public static function RotateXYcw(rot: double): Mtr4x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x2f(
cr, +sr,
-sr, cr,
0.0, 0.0,
0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x2f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x2f(
cr, -sr,
+sr, cr,
0.0, 0.0,
0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x2f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x2f; v: Vec2f): Vec4f := new Vec4f(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1, m.val20*v.val0+m.val21*v.val1, m.val30*v.val0+m.val31*v.val1);
public static function operator*(v: Vec4f; m: Mtr4x2f): Vec2f := new Vec2f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr4x2f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, m.val30, m.val31, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
end;
Mtr3x4f = record
public val00, val10, val20: single;
public val01, val11, val21: single;
public val02, val12, val22: single;
public val03, val13, val23: single;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13, val20, val21, val22, val23: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val23 := val23;
end;
public static property Identity: Mtr3x4f read new Mtr3x4f(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public property Row0: Vec4f read new Vec4f(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4f read new Vec4f(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Row2: Vec4f read new Vec4f(self.val20, self.val21, self.val22, self.val23) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; self.val23 := value.val3; end;
public property Col0: Vec3f read new Vec3f(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3f read new Vec3f(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property Col2: Vec3f read new Vec3f(self.val02, self.val12, self.val22) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; end;
public property Col3: Vec3f read new Vec3f(self.val03, self.val13, self.val23) write begin self.val03 := value.val0; self.val13 := value.val1; self.val23 := value.val2; end;
public property ColPtr0: ^Vec3f read pointer(@val00);
public property ColPtr1: ^Vec3f read pointer(@val01);
public property ColPtr2: ^Vec3f read pointer(@val02);
public property ColPtr3: ^Vec3f read pointer(@val03);
public property ColPtr[x: integer]: ^Vec3f read pointer(IntPtr(pointer(@self)) + x*12);
public procedure UseColPtr0(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec3fPtrCallbackP);
type PVec3f = ^Vec3f;
begin callback(PVec3f(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec3fPtrCallbackF<T>): T;
type PVec3f = ^Vec3f;
begin Result := callback(PVec3f(pointer(@val03))^); end;
public static function Scale(k: single): Mtr3x4f := new Mtr3x4f(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k, 0.0);
public static function Traslate(X, Y, Z: single): Mtr3x4f := new Mtr3x4f(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y, 0.0, 0.0, 1.0, Z);
public static function TraslateTransposed(X, Y: single): Mtr3x4f := new Mtr3x4f(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, X, Y, 1.0, 0.0);
public static function RotateXYcw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0
);
end;
public static function RotateYZcw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
1.0, 0.0, 0.0, 0.0,
0.0, cr, +sr, 0.0,
0.0, -sr, cr, 0.0
);
end;
public static function RotateYZccw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
1.0, 0.0, 0.0, 0.0,
0.0, cr, -sr, 0.0,
0.0, +sr, cr, 0.0
);
end;
public static function RotateZXcw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
cr, 0.0, -sr, 0.0,
0.0, 1.0, 0.0, 0.0,
+sr, 0.0, cr, 0.0
);
end;
public static function RotateZXccw(rot: double): Mtr3x4f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr3x4f(
cr, 0.0, +sr, 0.0,
0.0, 1.0, 0.0, 0.0,
-sr, 0.0, cr, 0.0
);
end;
public static function Rotate3Dcw(u: Vec3f; rot: double): Mtr3x4f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3f; rot: double): Mtr3x4f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[2,3] := (Sign(val23)=-1?'-':'+') + Abs(val23).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x4f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x4f; v: Vec4f): Vec3f := new Vec3f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2+m.val23*v.val3);
public static function operator*(v: Vec3f; m: Mtr3x4f): Vec4f := new Vec4f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2, m.val03*v.val0+m.val13*v.val1+m.val23*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr3x4f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr4x2f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
end;
Mtr4x3f = record
public val00, val10, val20, val30: single;
public val01, val11, val21, val31: single;
public val02, val12, val22, val32: single;
public constructor(val00, val01, val02, val10, val11, val12, val20, val21, val22, val30, val31, val32: single);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val30 := val30;
self.val31 := val31;
self.val32 := val32;
end;
public static property Identity: Mtr4x3f read new Mtr4x3f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public property Row0: Vec3f read new Vec3f(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3f read new Vec3f(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Row2: Vec3f read new Vec3f(self.val20, self.val21, self.val22) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; end;
public property Row3: Vec3f read new Vec3f(self.val30, self.val31, self.val32) write begin self.val30 := value.val0; self.val31 := value.val1; self.val32 := value.val2; end;
public property Col0: Vec4f read new Vec4f(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4f read new Vec4f(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property Col2: Vec4f read new Vec4f(self.val02, self.val12, self.val22, self.val32) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; self.val32 := value.val3; end;
public property ColPtr0: ^Vec4f read pointer(@val00);
public property ColPtr1: ^Vec4f read pointer(@val01);
public property ColPtr2: ^Vec4f read pointer(@val02);
public property ColPtr[x: integer]: ^Vec4f read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec4fPtrCallbackP);
type PVec4f = ^Vec4f;
begin callback(PVec4f(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec4fPtrCallbackF<T>): T;
type PVec4f = ^Vec4f;
begin Result := callback(PVec4f(pointer(@val02))^); end;
public static function Scale(k: single): Mtr4x3f := new Mtr4x3f(k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0);
public static function Traslate(X, Y: single): Mtr4x3f := new Mtr4x3f(1.0, 0.0, X, 0.0, 1.0, Y, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y, Z: single): Mtr4x3f := new Mtr4x3f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, X, Y, Z);
public static function RotateXYcw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
cr, +sr, 0.0,
-sr, cr, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
cr, -sr, 0.0,
+sr, cr, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, 0.0
);
end;
public static function RotateYZcw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
1.0, 0.0, 0.0,
0.0, cr, +sr,
0.0, -sr, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateYZccw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
1.0, 0.0, 0.0,
0.0, cr, -sr,
0.0, +sr, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateZXcw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
cr, 0.0, -sr,
0.0, 1.0, 0.0,
+sr, 0.0, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateZXccw(rot: double): Mtr4x3f;
begin
var sr: single := Sin(rot);
var cr: single := Cos(rot);
Result := new Mtr4x3f(
cr, 0.0, +sr,
0.0, 1.0, 0.0,
-sr, 0.0, cr,
0.0, 0.0, 0.0
);
end;
public static function Rotate3Dcw(u: Vec3f; rot: double): Mtr4x3f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3f; rot: double): Mtr4x3f;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
ElStrs[3,2] := (Sign(val32)=-1?'-':'+') + Abs(val32).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x3f;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x3f; v: Vec3f): Vec4f := new Vec4f(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2, m.val30*v.val0+m.val31*v.val1+m.val32*v.val2);
public static function operator*(v: Vec4f; m: Mtr4x3f): Vec3f := new Vec3f(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2+m.val32*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr4x3f): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, m.val30, m.val31, m.val32, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, m.val30, m.val31, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr3x4f): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
end;
Mtr2x2d = record
public val00, val10: double;
public val01, val11: double;
public constructor(val00, val01, val10, val11: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
end;
public static property Identity: Mtr2x2d read new Mtr2x2d(1.0, 0.0, 0.0, 1.0);
public property Row0: Vec2d read new Vec2d(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2d read new Vec2d(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Col0: Vec2d read new Vec2d(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2d read new Vec2d(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property ColPtr0: ^Vec2d read pointer(@val00);
public property ColPtr1: ^Vec2d read pointer(@val01);
public property ColPtr[x: integer]: ^Vec2d read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val01))^); end;
public static function Scale(k: double): Mtr2x2d := new Mtr2x2d(k, 0.0, 0.0, k);
public static function Traslate(X: double): Mtr2x2d := new Mtr2x2d(1.0, X, 0.0, 1.0);
public static function TraslateTransposed(X: double): Mtr2x2d := new Mtr2x2d(1.0, 0.0, X, 1.0);
public static function RotateXYcw(rot: double): Mtr2x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x2d(
cr, +sr,
-sr, cr
);
end;
public static function RotateXYccw(rot: double): Mtr2x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x2d(
cr, -sr,
+sr, cr
);
end;
public function Det: double :=
val00*val11 - val10*val01;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x2d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x2d; v: Vec2d): Vec2d := new Vec2d(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1);
public static function operator*(v: Vec2d; m: Mtr2x2d): Vec2d := new Vec2d(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1);
public static function operator implicit(m: Mtr2x2f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr2x2d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
end;
Mtr2d = Mtr2x2d;
Mtr3x3d = record
public val00, val10, val20: double;
public val01, val11, val21: double;
public val02, val12, val22: double;
public constructor(val00, val01, val02, val10, val11, val12, val20, val21, val22: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
end;
public static property Identity: Mtr3x3d read new Mtr3x3d(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
public property Row0: Vec3d read new Vec3d(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3d read new Vec3d(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Row2: Vec3d read new Vec3d(self.val20, self.val21, self.val22) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; end;
public property Col0: Vec3d read new Vec3d(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3d read new Vec3d(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property Col2: Vec3d read new Vec3d(self.val02, self.val12, self.val22) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; end;
public property ColPtr0: ^Vec3d read pointer(@val00);
public property ColPtr1: ^Vec3d read pointer(@val01);
public property ColPtr2: ^Vec3d read pointer(@val02);
public property ColPtr[x: integer]: ^Vec3d read pointer(IntPtr(pointer(@self)) + x*24);
public procedure UseColPtr0(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val02))^); end;
public static function Scale(k: double): Mtr3x3d := new Mtr3x3d(k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, k);
public static function Traslate(X, Y: double): Mtr3x3d := new Mtr3x3d(1.0, 0.0, X, 0.0, 1.0, Y, 0.0, 0.0, 1.0);
public static function TraslateTransposed(X, Y: double): Mtr3x3d := new Mtr3x3d(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, X, Y, 1.0);
public static function RotateXYcw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
cr, +sr, 0.0,
-sr, cr, 0.0,
0.0, 0.0, 1.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
cr, -sr, 0.0,
+sr, cr, 0.0,
0.0, 0.0, 1.0
);
end;
public static function RotateYZcw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
1.0, 0.0, 0.0,
0.0, cr, +sr,
0.0, -sr, cr
);
end;
public static function RotateYZccw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
1.0, 0.0, 0.0,
0.0, cr, -sr,
0.0, +sr, cr
);
end;
public static function RotateZXcw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
cr, 0.0, -sr,
0.0, 1.0, 0.0,
+sr, 0.0, cr
);
end;
public static function RotateZXccw(rot: double): Mtr3x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x3d(
cr, 0.0, +sr,
0.0, 1.0, 0.0,
-sr, 0.0, cr
);
end;
public static function Rotate3Dcw(u: Vec3d; rot: double): Mtr3x3d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3d; rot: double): Mtr3x3d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function Det: double :=
val00 * (val11*val22 - val21*val12) - val01 * (val10*val22 - val20*val12) + val02 * (val10*val21 - val20*val11);
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x3d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x3d; v: Vec3d): Vec3d := new Vec3d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2);
public static function operator*(v: Vec3d; m: Mtr3x3d): Vec3d := new Vec3d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr3x3d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr3x3d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr3x3d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr3x3d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr3x3d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
end;
Mtr3d = Mtr3x3d;
Mtr4x4d = record
public val00, val10, val20, val30: double;
public val01, val11, val21, val31: double;
public val02, val12, val22, val32: double;
public val03, val13, val23, val33: double;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13, val20, val21, val22, val23, val30, val31, val32, val33: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val23 := val23;
self.val30 := val30;
self.val31 := val31;
self.val32 := val32;
self.val33 := val33;
end;
public static property Identity: Mtr4x4d read new Mtr4x4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public property Row0: Vec4d read new Vec4d(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4d read new Vec4d(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Row2: Vec4d read new Vec4d(self.val20, self.val21, self.val22, self.val23) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; self.val23 := value.val3; end;
public property Row3: Vec4d read new Vec4d(self.val30, self.val31, self.val32, self.val33) write begin self.val30 := value.val0; self.val31 := value.val1; self.val32 := value.val2; self.val33 := value.val3; end;
public property Col0: Vec4d read new Vec4d(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4d read new Vec4d(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property Col2: Vec4d read new Vec4d(self.val02, self.val12, self.val22, self.val32) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; self.val32 := value.val3; end;
public property Col3: Vec4d read new Vec4d(self.val03, self.val13, self.val23, self.val33) write begin self.val03 := value.val0; self.val13 := value.val1; self.val23 := value.val2; self.val33 := value.val3; end;
public property ColPtr0: ^Vec4d read pointer(@val00);
public property ColPtr1: ^Vec4d read pointer(@val01);
public property ColPtr2: ^Vec4d read pointer(@val02);
public property ColPtr3: ^Vec4d read pointer(@val03);
public property ColPtr[x: integer]: ^Vec4d read pointer(IntPtr(pointer(@self)) + x*32);
public procedure UseColPtr0(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val03))^); end;
public static function Scale(k: double): Mtr4x4d := new Mtr4x4d(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k);
public static function Traslate(X, Y, Z: double): Mtr4x4d := new Mtr4x4d(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y, 0.0, 0.0, 1.0, Z, 0.0, 0.0, 0.0, 1.0);
public static function TraslateTransposed(X, Y, Z: double): Mtr4x4d := new Mtr4x4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, X, Y, Z, 1.0);
public static function RotateXYcw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateYZcw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
1.0, 0.0, 0.0, 0.0,
0.0, cr, +sr, 0.0,
0.0, -sr, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateYZccw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
1.0, 0.0, 0.0, 0.0,
0.0, cr, -sr, 0.0,
0.0, +sr, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateZXcw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
cr, 0.0, -sr, 0.0,
0.0, 1.0, 0.0, 0.0,
+sr, 0.0, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function RotateZXccw(rot: double): Mtr4x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x4d(
cr, 0.0, +sr, 0.0,
0.0, 1.0, 0.0, 0.0,
-sr, 0.0, cr, 0.0,
0.0, 0.0, 0.0, 1.0
);
end;
public static function Rotate3Dcw(u: Vec3d; rot: double): Mtr4x4d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
Result.val33 := 1;
end;
public static function Rotate3Dccw(u: Vec3d; rot: double): Mtr4x4d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
Result.val33 := 1;
end;
public function Det: double :=
val00 * (val11 * (val21*val32 - val31*val22) - val12 * (val22*val33 - val32*val23) + val13 * (val21*val33 - val31*val23)) - val01 * (val10 * (val22*val33 - val32*val23) - val12 * (val20*val32 - val30*val22) + val13 * (val20*val33 - val30*val23)) + val02 * (val10 * (val21*val33 - val31*val23) - val11 * (val20*val33 - val30*val23) + val13 * (val20*val31 - val30*val21)) - val03 * (val10 * (val21*val32 - val31*val22) - val11 * (val20*val32 - val30*val22) + val12 * (val20*val31 - val30*val21));
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[2,3] := (Sign(val23)=-1?'-':'+') + Abs(val23).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
ElStrs[3,2] := (Sign(val32)=-1?'-':'+') + Abs(val32).ToString('f2');
ElStrs[3,3] := (Sign(val33)=-1?'-':'+') + Abs(val33).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x4d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x4d; v: Vec4d): Vec4d := new Vec4d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2+m.val23*v.val3, m.val30*v.val0+m.val31*v.val1+m.val32*v.val2+m.val33*v.val3);
public static function operator*(v: Vec4d; m: Mtr4x4d): Vec4d := new Vec4d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2+m.val32*v.val3, m.val03*v.val0+m.val13*v.val1+m.val23*v.val2+m.val33*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, m.val30, m.val31, m.val32, m.val33);
public static function operator implicit(m: Mtr4x4d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, m.val30, m.val31, m.val32, m.val33);
public static function operator implicit(m: Mtr2x3f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr4x2f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, m.val30, m.val31, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr3x4f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr4x3f): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, m.val30, m.val31, m.val32, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr2x2d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
end;
Mtr4d = Mtr4x4d;
Mtr2x3d = record
public val00, val10: double;
public val01, val11: double;
public val02, val12: double;
public constructor(val00, val01, val02, val10, val11, val12: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
end;
public static property Identity: Mtr2x3d read new Mtr2x3d(1.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public property Row0: Vec3d read new Vec3d(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3d read new Vec3d(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Col0: Vec2d read new Vec2d(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2d read new Vec2d(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property Col2: Vec2d read new Vec2d(self.val02, self.val12) write begin self.val02 := value.val0; self.val12 := value.val1; end;
public property ColPtr0: ^Vec2d read pointer(@val00);
public property ColPtr1: ^Vec2d read pointer(@val01);
public property ColPtr2: ^Vec2d read pointer(@val02);
public property ColPtr[x: integer]: ^Vec2d read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val02))^); end;
public static function Scale(k: double): Mtr2x3d := new Mtr2x3d(k, 0.0, 0.0, 0.0, k, 0.0);
public static function Traslate(X, Y: double): Mtr2x3d := new Mtr2x3d(1.0, 0.0, X, 0.0, 1.0, Y);
public static function TraslateTransposed(X: double): Mtr2x3d := new Mtr2x3d(1.0, 0.0, 0.0, X, 1.0, 0.0);
public static function RotateXYcw(rot: double): Mtr2x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x3d(
cr, +sr, 0.0,
-sr, cr, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr2x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x3d(
cr, -sr, 0.0,
+sr, cr, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x3d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x3d; v: Vec3d): Vec2d := new Vec2d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2);
public static function operator*(v: Vec2d; m: Mtr2x3d): Vec3d := new Vec3d(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1, m.val02*v.val0+m.val12*v.val1);
public static function operator implicit(m: Mtr2x2f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr2x3d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr2x3d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr2x3d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr2x3d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr2x3d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
end;
Mtr3x2d = record
public val00, val10, val20: double;
public val01, val11, val21: double;
public constructor(val00, val01, val10, val11, val20, val21: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
self.val20 := val20;
self.val21 := val21;
end;
public static property Identity: Mtr3x2d read new Mtr3x2d(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
public property Row0: Vec2d read new Vec2d(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2d read new Vec2d(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Row2: Vec2d read new Vec2d(self.val20, self.val21) write begin self.val20 := value.val0; self.val21 := value.val1; end;
public property Col0: Vec3d read new Vec3d(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3d read new Vec3d(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property ColPtr0: ^Vec3d read pointer(@val00);
public property ColPtr1: ^Vec3d read pointer(@val01);
public property ColPtr[x: integer]: ^Vec3d read pointer(IntPtr(pointer(@self)) + x*24);
public procedure UseColPtr0(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val01))^); end;
public static function Scale(k: double): Mtr3x2d := new Mtr3x2d(k, 0.0, 0.0, k, 0.0, 0.0);
public static function Traslate(X: double): Mtr3x2d := new Mtr3x2d(1.0, X, 0.0, 1.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y: double): Mtr3x2d := new Mtr3x2d(1.0, 0.0, 0.0, 1.0, X, Y);
public static function RotateXYcw(rot: double): Mtr3x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x2d(
cr, +sr,
-sr, cr,
0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x2d(
cr, -sr,
+sr, cr,
0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x2d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x2d; v: Vec2d): Vec3d := new Vec3d(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1, m.val20*v.val0+m.val21*v.val1);
public static function operator*(v: Vec3d; m: Mtr3x2d): Vec2d := new Vec2d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr3x2d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
end;
Mtr2x4d = record
public val00, val10: double;
public val01, val11: double;
public val02, val12: double;
public val03, val13: double;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
end;
public static property Identity: Mtr2x4d read new Mtr2x4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
public property Row0: Vec4d read new Vec4d(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4d read new Vec4d(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Col0: Vec2d read new Vec2d(self.val00, self.val10) write begin self.val00 := value.val0; self.val10 := value.val1; end;
public property Col1: Vec2d read new Vec2d(self.val01, self.val11) write begin self.val01 := value.val0; self.val11 := value.val1; end;
public property Col2: Vec2d read new Vec2d(self.val02, self.val12) write begin self.val02 := value.val0; self.val12 := value.val1; end;
public property Col3: Vec2d read new Vec2d(self.val03, self.val13) write begin self.val03 := value.val0; self.val13 := value.val1; end;
public property ColPtr0: ^Vec2d read pointer(@val00);
public property ColPtr1: ^Vec2d read pointer(@val01);
public property ColPtr2: ^Vec2d read pointer(@val02);
public property ColPtr3: ^Vec2d read pointer(@val03);
public property ColPtr[x: integer]: ^Vec2d read pointer(IntPtr(pointer(@self)) + x*16);
public procedure UseColPtr0(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec2dPtrCallbackP);
type PVec2d = ^Vec2d;
begin callback(PVec2d(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec2dPtrCallbackF<T>): T;
type PVec2d = ^Vec2d;
begin Result := callback(PVec2d(pointer(@val03))^); end;
public static function Scale(k: double): Mtr2x4d := new Mtr2x4d(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0);
public static function Traslate(X, Y: double): Mtr2x4d := new Mtr2x4d(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y);
public static function TraslateTransposed(X: double): Mtr2x4d := new Mtr2x4d(1.0, 0.0, 0.0, 0.0, X, 1.0, 0.0, 0.0);
public static function RotateXYcw(rot: double): Mtr2x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x4d(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr2x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr2x4d(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[2,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr2x4d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr2x4d; v: Vec4d): Vec2d := new Vec2d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3);
public static function operator*(v: Vec2d; m: Mtr2x4d): Vec4d := new Vec4d(m.val00*v.val0+m.val10*v.val1, m.val01*v.val0+m.val11*v.val1, m.val02*v.val0+m.val12*v.val1, m.val03*v.val0+m.val13*v.val1);
public static function operator implicit(m: Mtr2x2f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr2x4d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr2x4d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr4x2f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr2x4d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr2x4d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr2x4d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0);
end;
Mtr4x2d = record
public val00, val10, val20, val30: double;
public val01, val11, val21, val31: double;
public constructor(val00, val01, val10, val11, val20, val21, val30, val31: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val10 := val10;
self.val11 := val11;
self.val20 := val20;
self.val21 := val21;
self.val30 := val30;
self.val31 := val31;
end;
public static property Identity: Mtr4x2d read new Mtr4x2d(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0);
public property Row0: Vec2d read new Vec2d(self.val00, self.val01) write begin self.val00 := value.val0; self.val01 := value.val1; end;
public property Row1: Vec2d read new Vec2d(self.val10, self.val11) write begin self.val10 := value.val0; self.val11 := value.val1; end;
public property Row2: Vec2d read new Vec2d(self.val20, self.val21) write begin self.val20 := value.val0; self.val21 := value.val1; end;
public property Row3: Vec2d read new Vec2d(self.val30, self.val31) write begin self.val30 := value.val0; self.val31 := value.val1; end;
public property Col0: Vec4d read new Vec4d(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4d read new Vec4d(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property ColPtr0: ^Vec4d read pointer(@val00);
public property ColPtr1: ^Vec4d read pointer(@val01);
public property ColPtr[x: integer]: ^Vec4d read pointer(IntPtr(pointer(@self)) + x*32);
public procedure UseColPtr0(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val01))^); end;
public function UseColPtr0<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val01))^); end;
public static function Scale(k: double): Mtr4x2d := new Mtr4x2d(k, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0);
public static function Traslate(X: double): Mtr4x2d := new Mtr4x2d(1.0, X, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y: double): Mtr4x2d := new Mtr4x2d(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, X, Y);
public static function RotateXYcw(rot: double): Mtr4x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x2d(
cr, +sr,
-sr, cr,
0.0, 0.0,
0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x2d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x2d(
cr, -sr,
+sr, cr,
0.0, 0.0,
0.0, 0.0
);
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,2];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*2 + 4; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x2d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x2d; v: Vec2d): Vec4d := new Vec4d(m.val00*v.val0+m.val01*v.val1, m.val10*v.val0+m.val11*v.val1, m.val20*v.val0+m.val21*v.val1, m.val30*v.val0+m.val31*v.val1);
public static function operator*(v: Vec4d; m: Mtr4x2d): Vec2d := new Vec2d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr4x2d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, m.val30, m.val31, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr3x2f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr4x2d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr3x4f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr4x2d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, m.val30, m.val31, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0);
public static function operator implicit(m: Mtr4x4d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr4x2d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0, m.val30, m.val31, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0);
public static function operator implicit(m: Mtr3x2d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0);
end;
Mtr3x4d = record
public val00, val10, val20: double;
public val01, val11, val21: double;
public val02, val12, val22: double;
public val03, val13, val23: double;
public constructor(val00, val01, val02, val03, val10, val11, val12, val13, val20, val21, val22, val23: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val03 := val03;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val13 := val13;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val23 := val23;
end;
public static property Identity: Mtr3x4d read new Mtr3x4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public property Row0: Vec4d read new Vec4d(self.val00, self.val01, self.val02, self.val03) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; self.val03 := value.val3; end;
public property Row1: Vec4d read new Vec4d(self.val10, self.val11, self.val12, self.val13) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; self.val13 := value.val3; end;
public property Row2: Vec4d read new Vec4d(self.val20, self.val21, self.val22, self.val23) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; self.val23 := value.val3; end;
public property Col0: Vec3d read new Vec3d(self.val00, self.val10, self.val20) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; end;
public property Col1: Vec3d read new Vec3d(self.val01, self.val11, self.val21) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; end;
public property Col2: Vec3d read new Vec3d(self.val02, self.val12, self.val22) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; end;
public property Col3: Vec3d read new Vec3d(self.val03, self.val13, self.val23) write begin self.val03 := value.val0; self.val13 := value.val1; self.val23 := value.val2; end;
public property ColPtr0: ^Vec3d read pointer(@val00);
public property ColPtr1: ^Vec3d read pointer(@val01);
public property ColPtr2: ^Vec3d read pointer(@val02);
public property ColPtr3: ^Vec3d read pointer(@val03);
public property ColPtr[x: integer]: ^Vec3d read pointer(IntPtr(pointer(@self)) + x*24);
public procedure UseColPtr0(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val02))^); end;
public procedure UseColPtr3(callback: UseVec3dPtrCallbackP);
type PVec3d = ^Vec3d;
begin callback(PVec3d(pointer(@val03))^); end;
public function UseColPtr0<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val02))^); end;
public function UseColPtr3<T>(callback: UseVec3dPtrCallbackF<T>): T;
type PVec3d = ^Vec3d;
begin Result := callback(PVec3d(pointer(@val03))^); end;
public static function Scale(k: double): Mtr3x4d := new Mtr3x4d(k, 0.0, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, 0.0, k, 0.0);
public static function Traslate(X, Y, Z: double): Mtr3x4d := new Mtr3x4d(1.0, 0.0, 0.0, X, 0.0, 1.0, 0.0, Y, 0.0, 0.0, 1.0, Z);
public static function TraslateTransposed(X, Y: double): Mtr3x4d := new Mtr3x4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, X, Y, 1.0, 0.0);
public static function RotateXYcw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
cr, +sr, 0.0, 0.0,
-sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
cr, -sr, 0.0, 0.0,
+sr, cr, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0
);
end;
public static function RotateYZcw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
1.0, 0.0, 0.0, 0.0,
0.0, cr, +sr, 0.0,
0.0, -sr, cr, 0.0
);
end;
public static function RotateYZccw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
1.0, 0.0, 0.0, 0.0,
0.0, cr, -sr, 0.0,
0.0, +sr, cr, 0.0
);
end;
public static function RotateZXcw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
cr, 0.0, -sr, 0.0,
0.0, 1.0, 0.0, 0.0,
+sr, 0.0, cr, 0.0
);
end;
public static function RotateZXccw(rot: double): Mtr3x4d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr3x4d(
cr, 0.0, +sr, 0.0,
0.0, 1.0, 0.0, 0.0,
-sr, 0.0, cr, 0.0
);
end;
public static function Rotate3Dcw(u: Vec3d; rot: double): Mtr3x4d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3d; rot: double): Mtr3x4d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[3,4];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[0,3] := (Sign(val03)=-1?'-':'+') + Abs(val03).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[1,3] := (Sign(val13)=-1?'-':'+') + Abs(val13).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[2,3] := (Sign(val23)=-1?'-':'+') + Abs(val23).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*4 + 8; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,3].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr3x4d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr3x4d; v: Vec4d): Vec3d := new Vec3d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2+m.val03*v.val3, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2+m.val13*v.val3, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2+m.val23*v.val3);
public static function operator*(v: Vec3d; m: Mtr3x4d): Vec4d := new Vec4d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2, m.val03*v.val0+m.val13*v.val1+m.val23*v.val2);
public static function operator implicit(m: Mtr2x2f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr3x4d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr4x2f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
public static function operator implicit(m: Mtr3x4f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr3x4d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr4x3f): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr2x2d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23);
public static function operator implicit(m: Mtr3x4d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, m.val20, m.val21, m.val22, m.val23, 0.0, 0.0, 0.0, 1.0);
public static function operator implicit(m: Mtr2x3d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13, 0.0, 0.0, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, m.val03, m.val10, m.val11, m.val12, m.val13);
public static function operator implicit(m: Mtr4x2d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, 0.0, 0.0, m.val10, m.val11, 0.0, 0.0, m.val20, m.val21, 1.0, 0.0);
public static function operator implicit(m: Mtr3x4d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, 0.0, 0.0);
end;
Mtr4x3d = record
public val00, val10, val20, val30: double;
public val01, val11, val21, val31: double;
public val02, val12, val22, val32: double;
public constructor(val00, val01, val02, val10, val11, val12, val20, val21, val22, val30, val31, val32: double);
begin
self.val00 := val00;
self.val01 := val01;
self.val02 := val02;
self.val10 := val10;
self.val11 := val11;
self.val12 := val12;
self.val20 := val20;
self.val21 := val21;
self.val22 := val22;
self.val30 := val30;
self.val31 := val31;
self.val32 := val32;
end;
public static property Identity: Mtr4x3d read new Mtr4x3d(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public property Row0: Vec3d read new Vec3d(self.val00, self.val01, self.val02) write begin self.val00 := value.val0; self.val01 := value.val1; self.val02 := value.val2; end;
public property Row1: Vec3d read new Vec3d(self.val10, self.val11, self.val12) write begin self.val10 := value.val0; self.val11 := value.val1; self.val12 := value.val2; end;
public property Row2: Vec3d read new Vec3d(self.val20, self.val21, self.val22) write begin self.val20 := value.val0; self.val21 := value.val1; self.val22 := value.val2; end;
public property Row3: Vec3d read new Vec3d(self.val30, self.val31, self.val32) write begin self.val30 := value.val0; self.val31 := value.val1; self.val32 := value.val2; end;
public property Col0: Vec4d read new Vec4d(self.val00, self.val10, self.val20, self.val30) write begin self.val00 := value.val0; self.val10 := value.val1; self.val20 := value.val2; self.val30 := value.val3; end;
public property Col1: Vec4d read new Vec4d(self.val01, self.val11, self.val21, self.val31) write begin self.val01 := value.val0; self.val11 := value.val1; self.val21 := value.val2; self.val31 := value.val3; end;
public property Col2: Vec4d read new Vec4d(self.val02, self.val12, self.val22, self.val32) write begin self.val02 := value.val0; self.val12 := value.val1; self.val22 := value.val2; self.val32 := value.val3; end;
public property ColPtr0: ^Vec4d read pointer(@val00);
public property ColPtr1: ^Vec4d read pointer(@val01);
public property ColPtr2: ^Vec4d read pointer(@val02);
public property ColPtr[x: integer]: ^Vec4d read pointer(IntPtr(pointer(@self)) + x*32);
public procedure UseColPtr0(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val00))^); end;
public procedure UseColPtr1(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val01))^); end;
public procedure UseColPtr2(callback: UseVec4dPtrCallbackP);
type PVec4d = ^Vec4d;
begin callback(PVec4d(pointer(@val02))^); end;
public function UseColPtr0<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val00))^); end;
public function UseColPtr1<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val01))^); end;
public function UseColPtr2<T>(callback: UseVec4dPtrCallbackF<T>): T;
type PVec4d = ^Vec4d;
begin Result := callback(PVec4d(pointer(@val02))^); end;
public static function Scale(k: double): Mtr4x3d := new Mtr4x3d(k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0, k, 0.0, 0.0, 0.0);
public static function Traslate(X, Y: double): Mtr4x3d := new Mtr4x3d(1.0, 0.0, X, 0.0, 1.0, Y, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function TraslateTransposed(X, Y, Z: double): Mtr4x3d := new Mtr4x3d(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, X, Y, Z);
public static function RotateXYcw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
cr, +sr, 0.0,
-sr, cr, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, 0.0
);
end;
public static function RotateXYccw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
cr, -sr, 0.0,
+sr, cr, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, 0.0
);
end;
public static function RotateYZcw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
1.0, 0.0, 0.0,
0.0, cr, +sr,
0.0, -sr, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateYZccw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
1.0, 0.0, 0.0,
0.0, cr, -sr,
0.0, +sr, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateZXcw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
cr, 0.0, -sr,
0.0, 1.0, 0.0,
+sr, 0.0, cr,
0.0, 0.0, 0.0
);
end;
public static function RotateZXccw(rot: double): Mtr4x3d;
begin
var sr: double := Sin(rot);
var cr: double := Cos(rot);
Result := new Mtr4x3d(
cr, 0.0, +sr,
0.0, 1.0, 0.0,
-sr, 0.0, cr,
0.0, 0.0, 0.0
);
end;
public static function Rotate3Dcw(u: Vec3d; rot: double): Mtr4x3d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := -k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := -k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := -k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public static function Rotate3Dccw(u: Vec3d; rot: double): Mtr4x3d;
begin
var k1 := Sin(rot);
var k2 := 2*Sqr(Sin(rot/2));
Result.val00 := 1 + k2*( -u.val2*u.val2 - u.val1*u.val1 );
Result.val01 := -k1*u.val2 + k2*( u.val1*u.val0 );
Result.val02 := k1*u.val1 + k2*( u.val2*u.val0 );
Result.val10 := k1*u.val2 + k2*( u.val0*u.val1 );
Result.val11 := 1 + k2*( -u.val2*u.val2 - u.val0*u.val0 );
Result.val12 := -k1*u.val0 + k2*( u.val2*u.val1 );
Result.val20 := -k1*u.val1 + k2*( u.val0*u.val2 );
Result.val21 := k1*u.val0 + k2*( u.val1*u.val2 );
Result.val22 := 1 + k2*( -u.val1*u.val1 - u.val0*u.val0 );
end;
public function ToString: string; override;
begin
var res := new StringBuilder;
var ElStrs := new string[4,3];
ElStrs[0,0] := (Sign(val00)=-1?'-':'+') + Abs(val00).ToString('f2');
ElStrs[0,1] := (Sign(val01)=-1?'-':'+') + Abs(val01).ToString('f2');
ElStrs[0,2] := (Sign(val02)=-1?'-':'+') + Abs(val02).ToString('f2');
ElStrs[1,0] := (Sign(val10)=-1?'-':'+') + Abs(val10).ToString('f2');
ElStrs[1,1] := (Sign(val11)=-1?'-':'+') + Abs(val11).ToString('f2');
ElStrs[1,2] := (Sign(val12)=-1?'-':'+') + Abs(val12).ToString('f2');
ElStrs[2,0] := (Sign(val20)=-1?'-':'+') + Abs(val20).ToString('f2');
ElStrs[2,1] := (Sign(val21)=-1?'-':'+') + Abs(val21).ToString('f2');
ElStrs[2,2] := (Sign(val22)=-1?'-':'+') + Abs(val22).ToString('f2');
ElStrs[3,0] := (Sign(val30)=-1?'-':'+') + Abs(val30).ToString('f2');
ElStrs[3,1] := (Sign(val31)=-1?'-':'+') + Abs(val31).ToString('f2');
ElStrs[3,2] := (Sign(val32)=-1?'-':'+') + Abs(val32).ToString('f2');
var MtrElTextW := ElStrs.OfType&<string>.Max(s->s.Length);
var PrintlnMtrW := MtrElTextW*3 + 6; // +2*(Width-1) + 2;
res += '┌';
res.Append(#32, PrintlnMtrW);
res += '┐'#10;
res += '│ ';
res += ElStrs[0,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[0,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[1,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[1,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[2,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[2,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '│ ';
res += ElStrs[3,0].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,1].PadLeft(MtrElTextW);
res += ', ';
res += ElStrs[3,2].PadLeft(MtrElTextW);
res += ' │'#10;
res += '└';
res.Append(#32, PrintlnMtrW);
res += '┘';
Result := res.ToString;
end;
public function Println: Mtr4x3d;
begin
Writeln(self.ToString);
Result := self;
end;
public static function operator*(m: Mtr4x3d; v: Vec3d): Vec4d := new Vec4d(m.val00*v.val0+m.val01*v.val1+m.val02*v.val2, m.val10*v.val0+m.val11*v.val1+m.val12*v.val2, m.val20*v.val0+m.val21*v.val1+m.val22*v.val2, m.val30*v.val0+m.val31*v.val1+m.val32*v.val2);
public static function operator*(v: Vec4d; m: Mtr4x3d): Vec3d := new Vec3d(m.val00*v.val0+m.val10*v.val1+m.val20*v.val2+m.val30*v.val3, m.val01*v.val0+m.val11*v.val1+m.val21*v.val2+m.val31*v.val3, m.val02*v.val0+m.val12*v.val1+m.val22*v.val2+m.val32*v.val3);
public static function operator implicit(m: Mtr2x2f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x2f := new Mtr2x2f(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x3f := new Mtr3x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr4x3d): Mtr4x4f := new Mtr4x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, m.val30, m.val31, m.val32, 1.0);
public static function operator implicit(m: Mtr2x3f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x3f := new Mtr2x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x2f := new Mtr3x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x4f := new Mtr2x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr4x2f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, m.val30, m.val31, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr4x2f := new Mtr4x2f(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr3x4f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x4f := new Mtr3x4f(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
public static function operator implicit(m: Mtr4x3f): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr4x3d): Mtr4x3f := new Mtr4x3f(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr2x2d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x2d := new Mtr2x2d(m.val00, m.val01, m.val10, m.val11);
public static function operator implicit(m: Mtr3x3d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x3d := new Mtr3x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22);
public static function operator implicit(m: Mtr4x4d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, m.val30, m.val31, m.val32);
public static function operator implicit(m: Mtr4x3d): Mtr4x4d := new Mtr4x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0, m.val30, m.val31, m.val32, 1.0);
public static function operator implicit(m: Mtr2x3d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x3d := new Mtr2x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12);
public static function operator implicit(m: Mtr3x2d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x2d := new Mtr3x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21);
public static function operator implicit(m: Mtr2x4d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr2x4d := new Mtr2x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0);
public static function operator implicit(m: Mtr4x2d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, 0.0, m.val10, m.val11, 0.0, m.val20, m.val21, 1.0, m.val30, m.val31, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr4x2d := new Mtr4x2d(m.val00, m.val01, m.val10, m.val11, m.val20, m.val21, m.val30, m.val31);
public static function operator implicit(m: Mtr3x4d): Mtr4x3d := new Mtr4x3d(m.val00, m.val01, m.val02, m.val10, m.val11, m.val12, m.val20, m.val21, m.val22, 0.0, 0.0, 0.0);
public static function operator implicit(m: Mtr4x3d): Mtr3x4d := new Mtr3x4d(m.val00, m.val01, m.val02, 0.0, m.val10, m.val11, m.val12, 0.0, m.val20, m.val21, m.val22, 0.0);
end;
{$endregion Mtr}
{$region Misc}
Fixed = record
public val: UInt32;
public constructor(val: UInt32);
begin
self.val := val;
end;
end;
GDI_COLORREF = record
private a: byte := 0;
public r: byte;
public g: byte;
public b: byte;
public constructor(r: byte; g: byte; b: byte);
begin
self.r := r;
self.g := g;
self.b := b;
end;
end;
GDI_GlyphmetricsFloat = record
public gmfBlackBoxX: single;
public gmfBlackBoxY: single;
public gmfptGlyphOriginX: single;
public gmfptGlyphOriginY: single;
public gmfCellIncX: single;
public gmfCellIncY: single;
public constructor(gmfBlackBoxX: single; gmfBlackBoxY: single; gmfptGlyphOriginX: single; gmfptGlyphOriginY: single; gmfCellIncX: single; gmfCellIncY: single);
begin
self.gmfBlackBoxX := gmfBlackBoxX;
self.gmfBlackBoxY := gmfBlackBoxY;
self.gmfptGlyphOriginX := gmfptGlyphOriginX;
self.gmfptGlyphOriginY := gmfptGlyphOriginY;
self.gmfCellIncX := gmfCellIncX;
self.gmfCellIncY := gmfCellIncY;
end;
end;
GDI_PixelFormatDescriptor = record
private nSize: UInt16 := sizeof(GDI_PixelFormatDescriptor);
public nVersion: UInt16 := 1;
public dwFlags: PixelFormatFlagsGDI;
public iPixelType: PixelDataTypeGDI;
public cColorBits: Byte; // Кол-во бит для R+G+B
public cRedBits: Byte; // Если оставить эти 6 нулями - их заполнит автоматически
public cRedShift: Byte;
public cGreenBits: Byte;
public cGreenShift: Byte;
public cBlueBits: Byte;
public cBlueShift: Byte;
public cAlphaBits: Byte; // Последние 2 не работают на Windows
public cAlphaShift: Byte;
public cAccumBits: Byte;
public cAccumRedBits: Byte;
public cAccumGreenBits: Byte;
public cAccumBlueBits: Byte;
public cAccumAlphaBits: Byte;
public cDepthBits: Byte;
public cStencilBits: Byte;
public cAuxBuffers: Byte; // Устарело
public iLayerType: Byte; // Устарело
public bLayersSize: Byte; // Устарело
public dwLayerMask: UInt32; // Не могу найти нормальное описание последних 3, но все оставляют их нулями
public dwVisibleMask: UInt32;
public dwDamageMask: UInt32;
public constructor(dwFlags: PixelFormatFlagsGDI; iPixelType: PixelDataTypeGDI; cColorBits: Byte; cRedBits: Byte; cRedShift: Byte; cGreenBits: Byte; cGreenShift: Byte; cBlueBits: Byte; cBlueShift: Byte; cAlphaBits: Byte; cAlphaShift: Byte; cAccumBits: Byte; cAccumRedBits: Byte; cAccumGreenBits: Byte; cAccumBlueBits: Byte; cAccumAlphaBits: Byte; cDepthBits: Byte; cStencilBits: Byte; cAuxBuffers: Byte; iLayerType: Byte; bLayersSize: Byte; dwLayerMask: UInt32; dwVisibleMask: UInt32; dwDamageMask: UInt32);
begin
self.dwFlags := dwFlags;
self.iPixelType := iPixelType;
self.cColorBits := cColorBits;
self.cRedBits := cRedBits;
self.cRedShift := cRedShift;
self.cGreenBits := cGreenBits;
self.cGreenShift := cGreenShift;
self.cBlueBits := cBlueBits;
self.cBlueShift := cBlueShift;
self.cAlphaBits := cAlphaBits;
self.cAlphaShift := cAlphaShift;
self.cAccumBits := cAccumBits;
self.cAccumRedBits := cAccumRedBits;
self.cAccumGreenBits := cAccumGreenBits;
self.cAccumBlueBits := cAccumBlueBits;
self.cAccumAlphaBits := cAccumAlphaBits;
self.cDepthBits := cDepthBits;
self.cStencilBits := cStencilBits;
self.cAuxBuffers := cAuxBuffers;
self.iLayerType := iLayerType;
self.bLayersSize := bLayersSize;
self.dwLayerMask := dwLayerMask;
self.dwVisibleMask := dwVisibleMask;
self.dwDamageMask := dwDamageMask;
end;
end;
Half = record
public val: UInt16;
public constructor(val: UInt16);
begin
self.val := val;
end;
end;
{$endregion Misc}
{$endregion Записи}
type
[PCUNotRestore]
gl = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
// added in gl4.1
private z_ActiveShaderProgram_adr := GetFuncAdr('glActiveShaderProgram');
private z_ActiveShaderProgram_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName; &program: ProgramName)>(z_ActiveShaderProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveShaderProgram(pipeline: ProgramPipelineName; &program: ProgramName) :=
z_ActiveShaderProgram_ovr_0(pipeline, &program);
// added in gl1.3
private z_ActiveTexture_adr := GetFuncAdr('glActiveTexture');
private z_ActiveTexture_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ActiveTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveTexture(texture: TextureUnit) :=
z_ActiveTexture_ovr_0(texture);
// added in gl2.0
private z_AttachShader_adr := GetFuncAdr('glAttachShader');
private z_AttachShader_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; shader: ShaderName)>(z_AttachShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AttachShader(&program: ProgramName; shader: ShaderName) :=
z_AttachShader_ovr_0(&program, shader);
// added in gl3.0
private z_BeginConditionalRender_adr := GetFuncAdr('glBeginConditionalRender');
private z_BeginConditionalRender_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; mode: ConditionalRenderMode)>(z_BeginConditionalRender_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRender(id: UInt32; mode: ConditionalRenderMode) :=
z_BeginConditionalRender_ovr_0(id, mode);
// added in gl1.5
private z_BeginQuery_adr := GetFuncAdr('glBeginQuery');
private z_BeginQuery_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; id: QueryName)>(z_BeginQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQuery(target: QueryTarget; id: QueryName) :=
z_BeginQuery_ovr_0(target, id);
// added in gl4.0
private z_BeginQueryIndexed_adr := GetFuncAdr('glBeginQueryIndexed');
private z_BeginQueryIndexed_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32; id: QueryName)>(z_BeginQueryIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQueryIndexed(target: QueryTarget; index: UInt32; id: QueryName) :=
z_BeginQueryIndexed_ovr_0(target, index, id);
// added in gl3.0
private z_BeginTransformFeedback_adr := GetFuncAdr('glBeginTransformFeedback');
private z_BeginTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: PrimitiveType)>(z_BeginTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedback(primitiveMode: PrimitiveType) :=
z_BeginTransformFeedback_ovr_0(primitiveMode);
// added in gl2.0
private z_BindAttribLocation_adr := GetFuncAdr('glBindAttribLocation');
private z_BindAttribLocation_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; index: UInt32; name: IntPtr)>(z_BindAttribLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindAttribLocation(&program: ProgramName; index: UInt32; name: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindAttribLocation_ovr_0(&program, index, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindAttribLocation(&program: ProgramName; index: UInt32; name: IntPtr) :=
z_BindAttribLocation_ovr_0(&program, index, name);
// added in gl1.5
private z_BindBuffer_adr := GetFuncAdr('glBindBuffer');
private z_BindBuffer_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; buffer: BufferName)>(z_BindBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffer(target: BufferTargetARB; buffer: BufferName) :=
z_BindBuffer_ovr_0(target, buffer);
// added in gl3.0
private z_BindBufferBase_adr := GetFuncAdr('glBindBufferBase');
private z_BindBufferBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: BufferName)>(z_BindBufferBase_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTargetARB; index: UInt32; buffer: BufferName) :=
z_BindBufferBase_ovr_0(target, index, buffer);
// added in gl3.0
private z_BindBufferRange_adr := GetFuncAdr('glBindBufferRange');
private z_BindBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr)>(z_BindBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTargetARB; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_BindBufferRange_ovr_0(target, index, buffer, offset, size);
// added in gl4.4
private z_BindBuffersBase_adr := GetFuncAdr('glBindBuffersBase');
private z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32)>(z_BindBuffersBase_adr);
private z_BindBuffersBase_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersBase_ovr_0(target, first, count, buffers[0]) else
z_BindBuffersBase_ovr_0_anh00001(target, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32) :=
z_BindBuffersBase_ovr_0(target, first, count, buffers);
private z_BindBuffersBase_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr) :=
z_BindBuffersBase_ovr_2(target, first, count, buffers);
// added in gl4.4
private z_BindBuffersRange_adr := GetFuncAdr('glBindBuffersRange');
private z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_0_anh0000111 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000111(target, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private z_BindBuffersRange_ovr_1_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_1_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_1_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_2_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_2_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_2_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_3_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_3_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_3_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers[0], offsets, IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_BindBuffersRange_ovr_4_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private z_BindBuffersRange_ovr_5_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_6_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_6_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_6_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers[0], offsets, IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_BindBuffersRange_ovr_7_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_8_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_8(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_8_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private z_BindBuffersRange_ovr_9_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_9_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_9_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_BindBuffersRange_ovr_10_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var sizes: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_11_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: pointer) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_12_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: pointer) :=
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets, sizes);
private z_BindBuffersRange_ovr_15_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: pointer) :=
z_BindBuffersRange_ovr_8(target, first, count, buffers, offsets, sizes);
private z_BindBuffersRange_ovr_18 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_18_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_18_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_18_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_BindBuffersRange_ovr_19_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_20 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_20_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_20_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private z_BindBuffersRange_ovr_21_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets, sizes);
private z_BindBuffersRange_ovr_24 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
private z_BindBuffersRange_ovr_24_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_24_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes);
private z_BindBuffersRange_ovr_26 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
z_BindBuffersRange_ovr_26(target, first, count, buffers, offsets, sizes);
// added in gl3.0
private z_BindFragDataLocation_adr := GetFuncAdr('glBindFragDataLocation');
private z_BindFragDataLocation_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; color: UInt32; name: IntPtr)>(z_BindFragDataLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocation(&program: ProgramName; color: UInt32; name: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindFragDataLocation_ovr_0(&program, color, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocation(&program: ProgramName; color: UInt32; name: IntPtr) :=
z_BindFragDataLocation_ovr_0(&program, color, name);
// added in gl3.3
private z_BindFragDataLocationIndexed_adr := GetFuncAdr('glBindFragDataLocationIndexed');
private z_BindFragDataLocationIndexed_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: IntPtr)>(z_BindFragDataLocationIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationIndexed(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindFragDataLocationIndexed_ovr_0(&program, colorNumber, index, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationIndexed(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: IntPtr) :=
z_BindFragDataLocationIndexed_ovr_0(&program, colorNumber, index, name);
// added in gl3.0
private z_BindFramebuffer_adr := GetFuncAdr('glBindFramebuffer');
private z_BindFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; framebuffer: FramebufferName)>(z_BindFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFramebuffer(target: FramebufferTarget; framebuffer: FramebufferName) :=
z_BindFramebuffer_ovr_0(target, framebuffer);
// added in gl4.2
private z_BindImageTexture_adr := GetFuncAdr('glBindImageTexture');
private z_BindImageTexture_ovr_0 := GetFuncOrNil&<procedure(&unit: UInt32; texture: TextureName; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: InternalFormat)>(z_BindImageTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTexture(&unit: UInt32; texture: TextureName; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: InternalFormat) :=
z_BindImageTexture_ovr_0(&unit, texture, level, layered, layer, access, format);
// added in gl4.4
private z_BindImageTextures_adr := GetFuncAdr('glBindImageTextures');
private z_BindImageTextures_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var textures: UInt32)>(z_BindImageTextures_adr);
private z_BindImageTextures_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; textures: IntPtr)>(z_BindImageTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_BindImageTextures_ovr_0(first, count, textures[0]) else
z_BindImageTextures_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; var textures: UInt32) :=
z_BindImageTextures_ovr_0(first, count, textures);
private z_BindImageTextures_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; textures: IntPtr)>(z_BindImageTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; textures: IntPtr) :=
z_BindImageTextures_ovr_2(first, count, textures);
// added in gl4.1
private z_BindProgramPipeline_adr := GetFuncAdr('glBindProgramPipeline');
private z_BindProgramPipeline_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName)>(z_BindProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramPipeline(pipeline: ProgramPipelineName) :=
z_BindProgramPipeline_ovr_0(pipeline);
// added in gl3.0
private z_BindRenderbuffer_adr := GetFuncAdr('glBindRenderbuffer');
private z_BindRenderbuffer_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; renderbuffer: RenderbufferName)>(z_BindRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindRenderbuffer(target: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_BindRenderbuffer_ovr_0(target, renderbuffer);
// added in gl3.3
private z_BindSampler_adr := GetFuncAdr('glBindSampler');
private z_BindSampler_ovr_0 := GetFuncOrNil&<procedure(&unit: UInt32; sampler: SamplerName)>(z_BindSampler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSampler(&unit: UInt32; sampler: SamplerName) :=
z_BindSampler_ovr_0(&unit, sampler);
// added in gl4.4
private z_BindSamplers_adr := GetFuncAdr('glBindSamplers');
private z_BindSamplers_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var samplers: UInt32)>(z_BindSamplers_adr);
private z_BindSamplers_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; samplers: IntPtr)>(z_BindSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_BindSamplers_ovr_0(first, count, samplers[0]) else
z_BindSamplers_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; var samplers: UInt32) :=
z_BindSamplers_ovr_0(first, count, samplers);
private z_BindSamplers_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; samplers: IntPtr)>(z_BindSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; samplers: IntPtr) :=
z_BindSamplers_ovr_2(first, count, samplers);
// added in gl1.1
private static procedure z_BindTexture_ovr_0(target: TextureTarget; texture: TextureName);
external 'opengl32.dll' name 'glBindTexture';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTexture(target: TextureTarget; texture: TextureName) :=
z_BindTexture_ovr_0(target, texture);
// added in gl4.4
private z_BindTextures_adr := GetFuncAdr('glBindTextures');
private z_BindTextures_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var textures: UInt32)>(z_BindTextures_adr);
private z_BindTextures_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; textures: IntPtr)>(z_BindTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_BindTextures_ovr_0(first, count, textures[0]) else
z_BindTextures_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; var textures: UInt32) :=
z_BindTextures_ovr_0(first, count, textures);
private z_BindTextures_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; textures: IntPtr)>(z_BindTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; textures: IntPtr) :=
z_BindTextures_ovr_2(first, count, textures);
// added in gl4.5
private z_BindTextureUnit_adr := GetFuncAdr('glBindTextureUnit');
private z_BindTextureUnit_ovr_0 := GetFuncOrNil&<procedure(&unit: UInt32; texture: TextureName)>(z_BindTextureUnit_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextureUnit(&unit: UInt32; texture: TextureName) :=
z_BindTextureUnit_ovr_0(&unit, texture);
// added in gl4.0
private z_BindTransformFeedback_adr := GetFuncAdr('glBindTransformFeedback');
private z_BindTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(target: BindTransformFeedbackTarget; id: TransformFeedbackName)>(z_BindTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedback(target: BindTransformFeedbackTarget; id: TransformFeedbackName) :=
z_BindTransformFeedback_ovr_0(target, id);
// added in gl3.0
private z_BindVertexArray_adr := GetFuncAdr('glBindVertexArray');
private z_BindVertexArray_ovr_0 := GetFuncOrNil&<procedure(&array: VertexArrayName)>(z_BindVertexArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexArray(&array: VertexArrayName) :=
z_BindVertexArray_ovr_0(&array);
// added in gl4.3
private z_BindVertexBuffer_adr := GetFuncAdr('glBindVertexBuffer');
private z_BindVertexBuffer_ovr_0 := GetFuncOrNil&<procedure(bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32)>(z_BindVertexBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffer(bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32) :=
z_BindVertexBuffer_ovr_0(bindingindex, buffer, offset, stride);
// added in gl4.4
private z_BindVertexBuffers_adr := GetFuncAdr('glBindVertexBuffers');
private z_BindVertexBuffers_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000110 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000101 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000011 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_0_anh000111 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers[0], IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000011(first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000101(first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000111(first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private z_BindVertexBuffers_ovr_1_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_1_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_1_anh000110 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides);
private z_BindVertexBuffers_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_2_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_2_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_2_anh000110 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000010(first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2_anh000100(first, count, IntPtr.Zero, offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides);
private z_BindVertexBuffers_ovr_3_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_3_anh000101 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000101(first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_BindVertexBuffers_ovr_4_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets, strides);
private z_BindVertexBuffers_ovr_5_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_2_anh000100(first, count, IntPtr.Zero, offsets, strides);
private z_BindVertexBuffers_ovr_6 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_6_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_6_anh000001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_6_anh000101 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000001(first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6_anh000100(first, count, IntPtr.Zero, offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000101(first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_BindVertexBuffers_ovr_7_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_6_anh000100(first, count, IntPtr.Zero, offsets, strides);
private z_BindVertexBuffers_ovr_8 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_8_anh000100 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_8(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_8_anh000100(first, count, IntPtr.Zero, offsets, strides);
private z_BindVertexBuffers_ovr_9_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_9_anh000011 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000011(first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_BindVertexBuffers_ovr_10_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers, IntPtr.Zero, strides);
private z_BindVertexBuffers_ovr_11_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000010(first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32) :=
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr) :=
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32) :=
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr) :=
z_BindVertexBuffers_ovr_8(first, count, buffers, offsets, strides);
private z_BindVertexBuffers_ovr_18 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_18_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_18_anh000001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_18_anh000011 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_18_anh000001(first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18_anh000010(first, count, buffers, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_18_anh000011(first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_BindVertexBuffers_ovr_19_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_18_anh000010(first, count, buffers, IntPtr.Zero, strides);
private z_BindVertexBuffers_ovr_20 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_20_anh000010 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_20_anh000010(first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_18_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32) :=
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr) :=
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets, strides);
private z_BindVertexBuffers_ovr_24 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_BindVertexBuffers_adr);
private z_BindVertexBuffers_ovr_24_anh000001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_24_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32) :=
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides);
private z_BindVertexBuffers_ovr_26 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr) :=
z_BindVertexBuffers_ovr_26(first, count, buffers, offsets, strides);
// added in gl1.4
private z_BlendColor_adr := GetFuncAdr('glBlendColor');
private z_BlendColor_ovr_0 := GetFuncOrNil&<procedure(red: single; green: single; blue: single; alpha: single)>(z_BlendColor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColor(red: single; green: single; blue: single; alpha: single) :=
z_BlendColor_ovr_0(red, green, blue, alpha);
// added in gl1.4
private z_BlendEquation_adr := GetFuncAdr('glBlendEquation');
private z_BlendEquation_ovr_0 := GetFuncOrNil&<procedure(mode: BlendEquationModeEXT)>(z_BlendEquation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquation(mode: BlendEquationModeEXT) :=
z_BlendEquation_ovr_0(mode);
// added in gl4.0
private z_BlendEquationi_adr := GetFuncAdr('glBlendEquationi');
private z_BlendEquationi_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; mode: BlendEquationModeEXT)>(z_BlendEquationi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationi(buf: UInt32; mode: BlendEquationModeEXT) :=
z_BlendEquationi_ovr_0(buf, mode);
// added in gl2.0
private z_BlendEquationSeparate_adr := GetFuncAdr('glBlendEquationSeparate');
private z_BlendEquationSeparate_ovr_0 := GetFuncOrNil&<procedure(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparate(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT) :=
z_BlendEquationSeparate_ovr_0(modeRGB, modeAlpha);
// added in gl4.0
private z_BlendEquationSeparatei_adr := GetFuncAdr('glBlendEquationSeparatei');
private z_BlendEquationSeparatei_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparatei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparatei(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT) :=
z_BlendEquationSeparatei_ovr_0(buf, modeRGB, modeAlpha);
// added in gl1.0
private static procedure z_BlendFunc_ovr_0(sfactor: BlendingFactor; dfactor: BlendingFactor);
external 'opengl32.dll' name 'glBlendFunc';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFunc(sfactor: BlendingFactor; dfactor: BlendingFactor) :=
z_BlendFunc_ovr_0(sfactor, dfactor);
// added in gl4.0
private z_BlendFunci_adr := GetFuncAdr('glBlendFunci');
private z_BlendFunci_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; src: BlendingFactor; dst: BlendingFactor)>(z_BlendFunci_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFunci(buf: UInt32; src: BlendingFactor; dst: BlendingFactor) :=
z_BlendFunci_ovr_0(buf, src, dst);
// added in gl1.4
private z_BlendFuncSeparate_adr := GetFuncAdr('glBlendFuncSeparate');
private z_BlendFuncSeparate_ovr_0 := GetFuncOrNil&<procedure(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor)>(z_BlendFuncSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparate(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor) :=
z_BlendFuncSeparate_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
// added in gl4.0
private z_BlendFuncSeparatei_adr := GetFuncAdr('glBlendFuncSeparatei');
private z_BlendFuncSeparatei_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor)>(z_BlendFuncSeparatei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparatei(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor) :=
z_BlendFuncSeparatei_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
// added in gl3.0
private z_BlitFramebuffer_adr := GetFuncAdr('glBlitFramebuffer');
private z_BlitFramebuffer_ovr_0 := GetFuncOrNil&<procedure(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter)>(z_BlitFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlitFramebuffer(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter) :=
z_BlitFramebuffer_ovr_0(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
// added in gl4.5
private z_BlitNamedFramebuffer_adr := GetFuncAdr('glBlitNamedFramebuffer');
private z_BlitNamedFramebuffer_ovr_0 := GetFuncOrNil&<procedure(readFramebuffer: UInt32; drawFramebuffer: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter)>(z_BlitNamedFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlitNamedFramebuffer(readFramebuffer: UInt32; drawFramebuffer: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter) :=
z_BlitNamedFramebuffer_ovr_0(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
// added in gl1.5
private z_BufferData_adr := GetFuncAdr('glBufferData');
private z_BufferData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferData(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
z_BufferData_ovr_0(target, size, data, usage);
// added in gl4.4
private z_BufferStorage_adr := GetFuncAdr('glBufferStorage');
private z_BufferStorage_ovr_0 := GetFuncOrNil&<procedure(target: BufferStorageTarget; size: IntPtr; data: IntPtr; flags: BufferStorageMask)>(z_BufferStorage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorage(target: BufferStorageTarget; size: IntPtr; data: IntPtr; flags: BufferStorageMask) :=
z_BufferStorage_ovr_0(target, size, data, flags);
// added in gl1.5
private z_BufferSubData_adr := GetFuncAdr('glBufferSubData');
private z_BufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubData(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_BufferSubData_ovr_0(target, offset, size, data);
// added in gl3.0
private z_CheckFramebufferStatus_adr := GetFuncAdr('glCheckFramebufferStatus');
private z_CheckFramebufferStatus_ovr_0 := GetFuncOrNil&<function(target: FramebufferTarget): FramebufferStatus>(z_CheckFramebufferStatus_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckFramebufferStatus(target: FramebufferTarget): FramebufferStatus :=
z_CheckFramebufferStatus_ovr_0(target);
// added in gl4.5
private z_CheckNamedFramebufferStatus_adr := GetFuncAdr('glCheckNamedFramebufferStatus');
private z_CheckNamedFramebufferStatus_ovr_0 := GetFuncOrNil&<function(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus>(z_CheckNamedFramebufferStatus_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckNamedFramebufferStatus(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus :=
z_CheckNamedFramebufferStatus_ovr_0(framebuffer, target);
// added in gl3.0
private z_ClampColor_adr := GetFuncAdr('glClampColor');
private z_ClampColor_ovr_0 := GetFuncOrNil&<procedure(target: ClampColorTargetARB; clamp: ClampColorModeARB)>(z_ClampColor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClampColor(target: ClampColorTargetARB; clamp: ClampColorModeARB) :=
z_ClampColor_ovr_0(target, clamp);
// added in gl1.0
private static procedure z_Clear_ovr_0(mask: ClearBufferMask);
external 'opengl32.dll' name 'glClear';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Clear(mask: ClearBufferMask) :=
z_Clear_ovr_0(mask);
// added in gl4.3
private z_ClearBufferData_adr := GetFuncAdr('glClearBufferData');
private z_ClearBufferData_ovr_0 := GetFuncOrNil&<procedure(target: BufferStorageTarget; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferData(target: BufferStorageTarget; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearBufferData_ovr_0(target, _internalformat, format, &type, data);
// added in gl3.0
private z_ClearBufferfi_adr := GetFuncAdr('glClearBufferfi');
private z_ClearBufferfi_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32)>(z_ClearBufferfi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfi(_buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32) :=
z_ClearBufferfi_ovr_0(_buffer, drawbuffer, depth, stencil);
// added in gl3.0
private z_ClearBufferfv_adr := GetFuncAdr('glClearBufferfv');
private z_ClearBufferfv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: single)>(z_ClearBufferfv_adr);
private z_ClearBufferfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfv(_buffer: Buffer; drawbuffer: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ClearBufferfv_ovr_0(_buffer, drawbuffer, value[0]) else
z_ClearBufferfv_ovr_0_anh0001(_buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfv(_buffer: Buffer; drawbuffer: Int32; var value: single) :=
z_ClearBufferfv_ovr_0(_buffer, drawbuffer, value);
private z_ClearBufferfv_ovr_2 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfv(_buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearBufferfv_ovr_2(_buffer, drawbuffer, value);
// added in gl3.0
private z_ClearBufferiv_adr := GetFuncAdr('glClearBufferiv');
private z_ClearBufferiv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: Int32)>(z_ClearBufferiv_adr);
private z_ClearBufferiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferiv(_buffer: Buffer; drawbuffer: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearBufferiv_ovr_0(_buffer, drawbuffer, value[0]) else
z_ClearBufferiv_ovr_0_anh0001(_buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferiv(_buffer: Buffer; drawbuffer: Int32; var value: Int32) :=
z_ClearBufferiv_ovr_0(_buffer, drawbuffer, value);
private z_ClearBufferiv_ovr_2 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferiv(_buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearBufferiv_ovr_2(_buffer, drawbuffer, value);
// added in gl4.3
private z_ClearBufferSubData_adr := GetFuncAdr('glClearBufferSubData');
private z_ClearBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTargetARB; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearBufferSubData_ovr_0(target, _internalformat, offset, size, format, &type, data);
// added in gl3.0
private z_ClearBufferuiv_adr := GetFuncAdr('glClearBufferuiv');
private z_ClearBufferuiv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: UInt32)>(z_ClearBufferuiv_adr);
private z_ClearBufferuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferuiv(_buffer: Buffer; drawbuffer: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearBufferuiv_ovr_0(_buffer, drawbuffer, value[0]) else
z_ClearBufferuiv_ovr_0_anh0001(_buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferuiv(_buffer: Buffer; drawbuffer: Int32; var value: UInt32) :=
z_ClearBufferuiv_ovr_0(_buffer, drawbuffer, value);
private z_ClearBufferuiv_ovr_2 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearBufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferuiv(_buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearBufferuiv_ovr_2(_buffer, drawbuffer, value);
// added in gl1.0
private static procedure z_ClearColor_ovr_0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glClearColor';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColor(red: single; green: single; blue: single; alpha: single) :=
z_ClearColor_ovr_0(red, green, blue, alpha);
// added in gl1.0
private static procedure z_ClearDepth_ovr_0(depth: real);
external 'opengl32.dll' name 'glClearDepth';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepth(depth: real) :=
z_ClearDepth_ovr_0(depth);
// added in gl4.1
private z_ClearDepthf_adr := GetFuncAdr('glClearDepthf');
private z_ClearDepthf_ovr_0 := GetFuncOrNil&<procedure(d: single)>(z_ClearDepthf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthf(d: single) :=
z_ClearDepthf_ovr_0(d);
// added in gl4.5
private z_ClearNamedBufferData_adr := GetFuncAdr('glClearNamedBufferData');
private z_ClearNamedBufferData_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearNamedBufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferData(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferData_ovr_0(buffer, _internalformat, format, &type, data);
// added in gl4.5
private z_ClearNamedBufferSubData_adr := GetFuncAdr('glClearNamedBufferSubData');
private z_ClearNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearNamedBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferSubData(buffer: UInt32; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferSubData_ovr_0(buffer, _internalformat, offset, size, format, &type, data);
// added in gl4.5
private z_ClearNamedFramebufferfi_adr := GetFuncAdr('glClearNamedFramebufferfi');
private z_ClearNamedFramebufferfi_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32)>(z_ClearNamedFramebufferfi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfi(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32) :=
z_ClearNamedFramebufferfi_ovr_0(framebuffer, _buffer, drawbuffer, depth, stencil);
// added in gl4.5
private z_ClearNamedFramebufferfv_adr := GetFuncAdr('glClearNamedFramebufferfv');
private z_ClearNamedFramebufferfv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single)>(z_ClearNamedFramebufferfv_adr);
private z_ClearNamedFramebufferfv_ovr_0_anh00001 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferfv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single) :=
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private z_ClearNamedFramebufferfv_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferfv_ovr_2(framebuffer, _buffer, drawbuffer, value);
// added in gl4.5
private z_ClearNamedFramebufferiv_adr := GetFuncAdr('glClearNamedFramebufferiv');
private z_ClearNamedFramebufferiv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32)>(z_ClearNamedFramebufferiv_adr);
private z_ClearNamedFramebufferiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferiv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32) :=
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private z_ClearNamedFramebufferiv_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
// added in gl4.5
private z_ClearNamedFramebufferuiv_adr := GetFuncAdr('glClearNamedFramebufferuiv');
private z_ClearNamedFramebufferuiv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32)>(z_ClearNamedFramebufferuiv_adr);
private z_ClearNamedFramebufferuiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferuiv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32) :=
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private z_ClearNamedFramebufferuiv_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr)>(z_ClearNamedFramebufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferuiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
// added in gl1.0
private static procedure z_ClearStencil_ovr_0(s: Int32);
external 'opengl32.dll' name 'glClearStencil';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearStencil(s: Int32) :=
z_ClearStencil_ovr_0(s);
// added in gl4.4
private z_ClearTexImage_adr := GetFuncAdr('glClearTexImage');
private z_ClearTexImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearTexImage(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearTexImage_ovr_0(texture, level, format, &type, data);
// added in gl4.4
private z_ClearTexSubImage_adr := GetFuncAdr('glClearTexSubImage');
private z_ClearTexSubImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearTexSubImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearTexSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, data);
// added in gl3.2
private z_ClientWaitSync_adr := GetFuncAdr('glClientWaitSync');
private z_ClientWaitSync_ovr_0 := GetFuncOrNil&<function(sync: GLsync; flags: SyncObjectMask; timeout: UInt64): SyncStatus>(z_ClientWaitSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ClientWaitSync(sync: GLsync; flags: SyncObjectMask; timeout: UInt64): SyncStatus :=
z_ClientWaitSync_ovr_0(sync, flags, timeout);
// added in gl4.5
private z_ClipControl_adr := GetFuncAdr('glClipControl');
private z_ClipControl_ovr_0 := GetFuncOrNil&<procedure(origin: ClipControlOrigin; depth: ClipControlDepth)>(z_ClipControl_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipControl(origin: ClipControlOrigin; depth: ClipControlDepth) :=
z_ClipControl_ovr_0(origin, depth);
// added in gl1.0
private static procedure z_ColorMask_ovr_0(red: boolean; green: boolean; blue: boolean; alpha: boolean);
external 'opengl32.dll' name 'glColorMask';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMask(red: boolean; green: boolean; blue: boolean; alpha: boolean) :=
z_ColorMask_ovr_0(red, green, blue, alpha);
// added in gl3.0
private z_ColorMaski_adr := GetFuncAdr('glColorMaski');
private z_ColorMaski_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean)>(z_ColorMaski_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMaski(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean) :=
z_ColorMaski_ovr_0(index, r, g, b, a);
// added in gl3.3
private z_ColorP3ui_adr := GetFuncAdr('glColorP3ui');
private z_ColorP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_ColorP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3ui(&type: ColorPointerType; color: UInt32) :=
z_ColorP3ui_ovr_0(&type, color);
// added in gl3.3
private z_ColorP3uiv_adr := GetFuncAdr('glColorP3uiv');
private z_ColorP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_ColorP3uiv_adr);
private z_ColorP3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_ColorP3uiv_ovr_0(&type, color[0]) else
z_ColorP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; var color: UInt32) :=
z_ColorP3uiv_ovr_0(&type, color);
private z_ColorP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: IntPtr) :=
z_ColorP3uiv_ovr_2(&type, color);
// added in gl3.3
private z_ColorP4ui_adr := GetFuncAdr('glColorP4ui');
private z_ColorP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_ColorP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4ui(&type: ColorPointerType; color: UInt32) :=
z_ColorP4ui_ovr_0(&type, color);
// added in gl3.3
private z_ColorP4uiv_adr := GetFuncAdr('glColorP4uiv');
private z_ColorP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_ColorP4uiv_adr);
private z_ColorP4uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_ColorP4uiv_ovr_0(&type, color[0]) else
z_ColorP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; var color: UInt32) :=
z_ColorP4uiv_ovr_0(&type, color);
private z_ColorP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: IntPtr) :=
z_ColorP4uiv_ovr_2(&type, color);
// added in gl2.0
private z_CompileShader_adr := GetFuncAdr('glCompileShader');
private z_CompileShader_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName)>(z_CompileShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShader(shader: ShaderName) :=
z_CompileShader_ovr_0(shader);
// added in gl1.3
private z_CompressedTexImage1D_adr := GetFuncAdr('glCompressedTexImage1D');
private z_CompressedTexImage1D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage1D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage1D_ovr_0(target, level, _internalformat, width, border, imageSize, data);
// added in gl1.3
private z_CompressedTexImage2D_adr := GetFuncAdr('glCompressedTexImage2D');
private z_CompressedTexImage2D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage2D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage2D_ovr_0(target, level, _internalformat, width, height, border, imageSize, data);
// added in gl1.3
private z_CompressedTexImage3D_adr := GetFuncAdr('glCompressedTexImage3D');
private z_CompressedTexImage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage3D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage3D_ovr_0(target, level, _internalformat, width, height, depth, border, imageSize, data);
// added in gl1.3
private z_CompressedTexSubImage1D_adr := GetFuncAdr('glCompressedTexSubImage1D');
private z_CompressedTexSubImage1D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTexSubImage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage1D(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage1D_ovr_0(target, level, xoffset, width, format, imageSize, data);
// added in gl1.3
private z_CompressedTexSubImage2D_adr := GetFuncAdr('glCompressedTexSubImage2D');
private z_CompressedTexSubImage2D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTexSubImage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage2D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage2D_ovr_0(target, level, xoffset, yoffset, width, height, format, imageSize, data);
// added in gl1.3
private z_CompressedTexSubImage3D_adr := GetFuncAdr('glCompressedTexSubImage3D');
private z_CompressedTexSubImage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTexSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage3D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
// added in gl4.5
private z_CompressedTextureSubImage1D_adr := GetFuncAdr('glCompressedTextureSubImage1D');
private z_CompressedTextureSubImage1D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTextureSubImage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage1D(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage1D_ovr_0(texture, level, xoffset, width, format, imageSize, data);
// added in gl4.5
private z_CompressedTextureSubImage2D_adr := GetFuncAdr('glCompressedTextureSubImage2D');
private z_CompressedTextureSubImage2D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTextureSubImage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage2D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
// added in gl4.5
private z_CompressedTextureSubImage3D_adr := GetFuncAdr('glCompressedTextureSubImage3D');
private z_CompressedTextureSubImage3D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTextureSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage3D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
// added in gl3.1
private z_CopyBufferSubData_adr := GetFuncAdr('glCopyBufferSubData');
private z_CopyBufferSubData_ovr_0 := GetFuncOrNil&<procedure(readTarget: CopyBufferSubDataTarget; writeTarget: CopyBufferSubDataTarget; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr)>(z_CopyBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyBufferSubData(readTarget: CopyBufferSubDataTarget; writeTarget: CopyBufferSubDataTarget; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_CopyBufferSubData_ovr_0(readTarget, writeTarget, readOffset, writeOffset, size);
// added in gl4.3
private z_CopyImageSubData_adr := GetFuncAdr('glCopyImageSubData');
private z_CopyImageSubData_ovr_0 := GetFuncOrNil&<procedure(srcName: UInt32; srcTarget: CopyImageSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyImageSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32)>(z_CopyImageSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyImageSubData(srcName: UInt32; srcTarget: CopyImageSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyImageSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32) :=
z_CopyImageSubData_ovr_0(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
// added in gl4.5
private z_CopyNamedBufferSubData_adr := GetFuncAdr('glCopyNamedBufferSubData');
private z_CopyNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(readBuffer: BufferName; writeBuffer: BufferName; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr)>(z_CopyNamedBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyNamedBufferSubData(readBuffer: BufferName; writeBuffer: BufferName; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_CopyNamedBufferSubData_ovr_0(readBuffer, writeBuffer, readOffset, writeOffset, size);
// added in gl1.1
private static procedure z_CopyTexImage1D_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage1D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32) :=
z_CopyTexImage1D_ovr_0(target, level, _internalformat, x, y, width, border);
// added in gl1.1
private static procedure z_CopyTexImage2D_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage2D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32) :=
z_CopyTexImage2D_ovr_0(target, level, _internalformat, x, y, width, height, border);
// added in gl1.1
private static procedure z_CopyTexSubImage1D_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage1D(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyTexSubImage1D_ovr_0(target, level, xoffset, x, y, width);
// added in gl1.1
private static procedure z_CopyTexSubImage2D_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage2D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTexSubImage2D_ovr_0(target, level, xoffset, yoffset, x, y, width, height);
// added in gl1.2
private z_CopyTexSubImage3D_adr := GetFuncAdr('glCopyTexSubImage3D');
private z_CopyTexSubImage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTexSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage3D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, x, y, width, height);
// added in gl4.5
private z_CopyTextureSubImage1D_adr := GetFuncAdr('glCopyTextureSubImage1D');
private z_CopyTextureSubImage1D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32)>(z_CopyTextureSubImage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage1D(texture: TextureName; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyTextureSubImage1D_ovr_0(texture, level, xoffset, x, y, width);
// added in gl4.5
private z_CopyTextureSubImage2D_adr := GetFuncAdr('glCopyTextureSubImage2D');
private z_CopyTextureSubImage2D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTextureSubImage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage2D(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, x, y, width, height);
// added in gl4.5
private z_CopyTextureSubImage3D_adr := GetFuncAdr('glCopyTextureSubImage3D');
private z_CopyTextureSubImage3D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTextureSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage3D(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
// added in gl4.5
private z_CreateBuffers_adr := GetFuncAdr('glCreateBuffers');
private z_CreateBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: BufferName)>(z_CreateBuffers_adr);
private z_CreateBuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_CreateBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: array of BufferName) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_CreateBuffers_ovr_0(n, buffers[0]) else
z_CreateBuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; var buffers: BufferName) :=
z_CreateBuffers_ovr_0(n, buffers);
private z_CreateBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_CreateBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: IntPtr) :=
z_CreateBuffers_ovr_2(n, buffers);
// added in gl4.5
private z_CreateFramebuffers_adr := GetFuncAdr('glCreateFramebuffers');
private z_CreateFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_CreateFramebuffers_adr);
private z_CreateFramebuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_CreateFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_CreateFramebuffers_ovr_0(n, framebuffers[0]) else
z_CreateFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_CreateFramebuffers_ovr_0(n, framebuffers);
private z_CreateFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_CreateFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_CreateFramebuffers_ovr_2(n, framebuffers);
// added in gl2.0
private z_CreateProgram_adr := GetFuncAdr('glCreateProgram');
private z_CreateProgram_ovr_0 := GetFuncOrNil&<function: ProgramName>(z_CreateProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgram: ProgramName :=
z_CreateProgram_ovr_0;
// added in gl4.5
private z_CreateProgramPipelines_adr := GetFuncAdr('glCreateProgramPipelines');
private z_CreateProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_CreateProgramPipelines_adr);
private z_CreateProgramPipelines_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_CreateProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_CreateProgramPipelines_ovr_0(n, pipelines[0]) else
z_CreateProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_CreateProgramPipelines_ovr_0(n, pipelines);
private z_CreateProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_CreateProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_CreateProgramPipelines_ovr_2(n, pipelines);
// added in gl4.5
private z_CreateQueries_adr := GetFuncAdr('glCreateQueries');
private z_CreateQueries_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; n: Int32; var ids: UInt32)>(z_CreateQueries_adr);
private z_CreateQueries_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: QueryTarget; n: Int32; ids: IntPtr)>(z_CreateQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_CreateQueries_ovr_0(target, n, ids[0]) else
z_CreateQueries_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; var ids: UInt32) :=
z_CreateQueries_ovr_0(target, n, ids);
private z_CreateQueries_ovr_2 := GetFuncOrNil&<procedure(target: QueryTarget; n: Int32; ids: IntPtr)>(z_CreateQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; ids: IntPtr) :=
z_CreateQueries_ovr_2(target, n, ids);
// added in gl4.5
private z_CreateRenderbuffers_adr := GetFuncAdr('glCreateRenderbuffers');
private z_CreateRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_CreateRenderbuffers_adr);
private z_CreateRenderbuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_CreateRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_CreateRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_CreateRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_CreateRenderbuffers_ovr_0(n, renderbuffers);
private z_CreateRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_CreateRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_CreateRenderbuffers_ovr_2(n, renderbuffers);
// added in gl4.5
private z_CreateSamplers_adr := GetFuncAdr('glCreateSamplers');
private z_CreateSamplers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var samplers: UInt32)>(z_CreateSamplers_adr);
private z_CreateSamplers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; samplers: IntPtr)>(z_CreateSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_CreateSamplers_ovr_0(n, samplers[0]) else
z_CreateSamplers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; var samplers: UInt32) :=
z_CreateSamplers_ovr_0(n, samplers);
private z_CreateSamplers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; samplers: IntPtr)>(z_CreateSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: IntPtr) :=
z_CreateSamplers_ovr_2(n, samplers);
// added in gl2.0
private z_CreateShader_adr := GetFuncAdr('glCreateShader');
private z_CreateShader_ovr_0 := GetFuncOrNil&<function(&type: ShaderType): ShaderName>(z_CreateShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShader(&type: ShaderType): ShaderName :=
z_CreateShader_ovr_0(&type);
// added in gl4.1
private z_CreateShaderProgramv_adr := GetFuncAdr('glCreateShaderProgramv');
private z_CreateShaderProgramv_ovr_0 := GetFuncOrNil&<function(&type: ShaderType; count: Int32; var strings: IntPtr): ProgramName>(z_CreateShaderProgramv_adr);
private z_CreateShaderProgramv_ovr_0_anh0001 := GetFuncOrNil&<function(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName>(z_CreateShaderProgramv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: array of string): ProgramName;
begin
var par_3_str_ptr := strings?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
Result := z_CreateShaderProgramv_ovr_0(&type, count, par_3_str_ptr[0]) else
Result := z_CreateShaderProgramv_ovr_0_anh0001(&type, count, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_CreateShaderProgramv_ovr_1_anh0001 := GetFuncOrNil&<function(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName>(z_CreateShaderProgramv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: array of IntPtr): ProgramName :=
if (strings<>nil) and (strings.Length<>0) then
z_CreateShaderProgramv_ovr_0(&type, count, strings[0]) else
z_CreateShaderProgramv_ovr_0_anh0001(&type, count, IntPtr.Zero);
private z_CreateShaderProgramv_ovr_2 := GetFuncOrNil&<function(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName>(z_CreateShaderProgramv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName :=
z_CreateShaderProgramv_ovr_2(&type, count, strings);
// added in gl4.5
private z_CreateTextures_adr := GetFuncAdr('glCreateTextures');
private z_CreateTextures_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; var textures: UInt32)>(z_CreateTextures_adr);
private z_CreateTextures_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; textures: IntPtr)>(z_CreateTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_CreateTextures_ovr_0(target, n, textures[0]) else
z_CreateTextures_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; var textures: UInt32) :=
z_CreateTextures_ovr_0(target, n, textures);
private z_CreateTextures_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; textures: IntPtr)>(z_CreateTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; textures: IntPtr) :=
z_CreateTextures_ovr_2(target, n, textures);
// added in gl4.5
private z_CreateTransformFeedbacks_adr := GetFuncAdr('glCreateTransformFeedbacks');
private z_CreateTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_CreateTransformFeedbacks_adr);
private z_CreateTransformFeedbacks_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_CreateTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_CreateTransformFeedbacks_ovr_0(n, ids[0]) else
z_CreateTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_CreateTransformFeedbacks_ovr_0(n, ids);
private z_CreateTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_CreateTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_CreateTransformFeedbacks_ovr_2(n, ids);
// added in gl4.5
private z_CreateVertexArrays_adr := GetFuncAdr('glCreateVertexArrays');
private z_CreateVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_CreateVertexArrays_adr);
private z_CreateVertexArrays_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_CreateVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_CreateVertexArrays_ovr_0(n, arrays[0]) else
z_CreateVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; var arrays: UInt32) :=
z_CreateVertexArrays_ovr_0(n, arrays);
private z_CreateVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_CreateVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: IntPtr) :=
z_CreateVertexArrays_ovr_2(n, arrays);
// added in gl1.0
private static procedure z_CullFace_ovr_0(mode: CullFaceMode);
external 'opengl32.dll' name 'glCullFace';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullFace(mode: CullFaceMode) :=
z_CullFace_ovr_0(mode);
// added in gl4.3
private z_DebugMessageCallback_adr := GetFuncAdr('glDebugMessageCallback');
private z_DebugMessageCallback_ovr_0 := GetFuncOrNil&<procedure(callback: GLDEBUGPROC; userParam: IntPtr)>(z_DebugMessageCallback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallback(callback: GLDEBUGPROC; userParam: IntPtr) :=
z_DebugMessageCallback_ovr_0(callback, userParam);
// added in gl4.3
private z_DebugMessageControl_adr := GetFuncAdr('glDebugMessageControl');
private z_DebugMessageControl_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean)>(z_DebugMessageControl_adr);
private z_DebugMessageControl_ovr_0_anh0000010 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean)>(z_DebugMessageControl_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean) :=
if (ids<>nil) and (ids.Length<>0) then
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids[0], enabled) else
z_DebugMessageControl_ovr_0_anh0000010(source, &type, severity, count, IntPtr.Zero, enabled);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean) :=
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids, enabled);
private z_DebugMessageControl_ovr_2 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean)>(z_DebugMessageControl_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean) :=
z_DebugMessageControl_ovr_2(source, &type, severity, count, ids, enabled);
// added in gl4.3
private z_DebugMessageInsert_adr := GetFuncAdr('glDebugMessageInsert');
private z_DebugMessageInsert_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr)>(z_DebugMessageInsert_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsert(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: string);
begin
var par_6_str_ptr := Marshal.StringToHGlobalAnsi(buf);
z_DebugMessageInsert_ovr_0(source, &type, id, severity, length, par_6_str_ptr);
Marshal.FreeHGlobal(par_6_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsert(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr) :=
z_DebugMessageInsert_ovr_0(source, &type, id, severity, length, buf);
// added in gl1.5
private z_DeleteBuffers_adr := GetFuncAdr('glDeleteBuffers');
private z_DeleteBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: UInt32)>(z_DeleteBuffers_adr);
private z_DeleteBuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_DeleteBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; buffers: array of UInt32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_DeleteBuffers_ovr_0(n, buffers[0]) else
z_DeleteBuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; var buffers: UInt32) :=
z_DeleteBuffers_ovr_0(n, buffers);
private z_DeleteBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_DeleteBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; buffers: IntPtr) :=
z_DeleteBuffers_ovr_2(n, buffers);
// added in gl3.0
private z_DeleteFramebuffers_adr := GetFuncAdr('glDeleteFramebuffers');
private z_DeleteFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_DeleteFramebuffers_adr);
private z_DeleteFramebuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_DeleteFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_DeleteFramebuffers_ovr_0(n, framebuffers[0]) else
z_DeleteFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_DeleteFramebuffers_ovr_0(n, framebuffers);
private z_DeleteFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_DeleteFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_DeleteFramebuffers_ovr_2(n, framebuffers);
// added in gl2.0
private z_DeleteProgram_adr := GetFuncAdr('glDeleteProgram');
private z_DeleteProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_DeleteProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgram(&program: ProgramName) :=
z_DeleteProgram_ovr_0(&program);
// added in gl4.1
private z_DeleteProgramPipelines_adr := GetFuncAdr('glDeleteProgramPipelines');
private z_DeleteProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_DeleteProgramPipelines_adr);
private z_DeleteProgramPipelines_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_DeleteProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_DeleteProgramPipelines_ovr_0(n, pipelines[0]) else
z_DeleteProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_DeleteProgramPipelines_ovr_0(n, pipelines);
private z_DeleteProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_DeleteProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_DeleteProgramPipelines_ovr_2(n, pipelines);
// added in gl1.5
private z_DeleteQueries_adr := GetFuncAdr('glDeleteQueries');
private z_DeleteQueries_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteQueries_adr);
private z_DeleteQueries_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteQueries_ovr_0(n, ids[0]) else
z_DeleteQueries_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; var ids: UInt32) :=
z_DeleteQueries_ovr_0(n, ids);
private z_DeleteQueries_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; ids: IntPtr) :=
z_DeleteQueries_ovr_2(n, ids);
// added in gl3.0
private z_DeleteRenderbuffers_adr := GetFuncAdr('glDeleteRenderbuffers');
private z_DeleteRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_DeleteRenderbuffers_adr);
private z_DeleteRenderbuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_DeleteRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_DeleteRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_DeleteRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_DeleteRenderbuffers_ovr_0(n, renderbuffers);
private z_DeleteRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_DeleteRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_DeleteRenderbuffers_ovr_2(n, renderbuffers);
// added in gl3.3
private z_DeleteSamplers_adr := GetFuncAdr('glDeleteSamplers');
private z_DeleteSamplers_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var samplers: UInt32)>(z_DeleteSamplers_adr);
private z_DeleteSamplers_ovr_0_anh001 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_DeleteSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_DeleteSamplers_ovr_0(count, samplers[0]) else
z_DeleteSamplers_ovr_0_anh001(count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; var samplers: UInt32) :=
z_DeleteSamplers_ovr_0(count, samplers);
private z_DeleteSamplers_ovr_2 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_DeleteSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: IntPtr) :=
z_DeleteSamplers_ovr_2(count, samplers);
// added in gl2.0
private z_DeleteShader_adr := GetFuncAdr('glDeleteShader');
private z_DeleteShader_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName)>(z_DeleteShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteShader(shader: ShaderName) :=
z_DeleteShader_ovr_0(shader);
// added in gl3.2
private z_DeleteSync_adr := GetFuncAdr('glDeleteSync');
private z_DeleteSync_ovr_0 := GetFuncOrNil&<procedure(sync: GLsync)>(z_DeleteSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSync(sync: GLsync) :=
z_DeleteSync_ovr_0(sync);
// added in gl1.1
private static procedure z_DeleteTextures_ovr_0(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glDeleteTextures';
private static procedure z_DeleteTextures_ovr_0_anh001(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glDeleteTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_DeleteTextures_ovr_0(n, textures[0]) else
z_DeleteTextures_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; var textures: UInt32) :=
z_DeleteTextures_ovr_0(n, textures);
private static procedure z_DeleteTextures_ovr_2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glDeleteTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; textures: IntPtr) :=
z_DeleteTextures_ovr_2(n, textures);
// added in gl4.0
private z_DeleteTransformFeedbacks_adr := GetFuncAdr('glDeleteTransformFeedbacks');
private z_DeleteTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteTransformFeedbacks_adr);
private z_DeleteTransformFeedbacks_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteTransformFeedbacks_ovr_0(n, ids[0]) else
z_DeleteTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_DeleteTransformFeedbacks_ovr_0(n, ids);
private z_DeleteTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_DeleteTransformFeedbacks_ovr_2(n, ids);
// added in gl3.0
private z_DeleteVertexArrays_adr := GetFuncAdr('glDeleteVertexArrays');
private z_DeleteVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_DeleteVertexArrays_adr);
private z_DeleteVertexArrays_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_DeleteVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_DeleteVertexArrays_ovr_0(n, arrays[0]) else
z_DeleteVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; var arrays: UInt32) :=
z_DeleteVertexArrays_ovr_0(n, arrays);
private z_DeleteVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_DeleteVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: IntPtr) :=
z_DeleteVertexArrays_ovr_2(n, arrays);
// added in gl1.0
private static procedure z_DepthFunc_ovr_0(func: DepthFunction);
external 'opengl32.dll' name 'glDepthFunc';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthFunc(func: DepthFunction) :=
z_DepthFunc_ovr_0(func);
// added in gl1.0
private static procedure z_DepthMask_ovr_0(flag: boolean);
external 'opengl32.dll' name 'glDepthMask';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthMask(flag: boolean) :=
z_DepthMask_ovr_0(flag);
// added in gl1.0
private static procedure z_DepthRange_ovr_0(n: real; f: real);
external 'opengl32.dll' name 'glDepthRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRange(n: real; f: real) :=
z_DepthRange_ovr_0(n, f);
// added in gl4.1
private z_DepthRangeArrayv_adr := GetFuncAdr('glDepthRangeArrayv');
private z_DepthRangeArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: real)>(z_DepthRangeArrayv_adr);
private z_DepthRangeArrayv_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_DepthRangeArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_DepthRangeArrayv_ovr_0(first, count, v[0]) else
z_DepthRangeArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; var v: real) :=
z_DepthRangeArrayv_ovr_0(first, count, v);
private z_DepthRangeArrayv_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_DepthRangeArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_DepthRangeArrayv_ovr_2(first, count, v);
// added in gl4.1
private z_DepthRangef_adr := GetFuncAdr('glDepthRangef');
private z_DepthRangef_ovr_0 := GetFuncOrNil&<procedure(n: single; f: single)>(z_DepthRangef_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangef(n: single; f: single) :=
z_DepthRangef_ovr_0(n, f);
// added in gl4.1
private z_DepthRangeIndexed_adr := GetFuncAdr('glDepthRangeIndexed');
private z_DepthRangeIndexed_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; n: real; f: real)>(z_DepthRangeIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeIndexed(index: UInt32; n: real; f: real) :=
z_DepthRangeIndexed_ovr_0(index, n, f);
// added in gl2.0
private z_DetachShader_adr := GetFuncAdr('glDetachShader');
private z_DetachShader_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; shader: ShaderName)>(z_DetachShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetachShader(&program: ProgramName; shader: ShaderName) :=
z_DetachShader_ovr_0(&program, shader);
// added in gl1.0
private static procedure z_Disable_ovr_0(cap: EnableCap);
external 'opengl32.dll' name 'glDisable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Disable(cap: EnableCap) :=
z_Disable_ovr_0(cap);
// added in gl3.0
private z_Disablei_adr := GetFuncAdr('glDisablei');
private z_Disablei_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_Disablei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Disablei(target: EnableCap; index: UInt32) :=
z_Disablei_ovr_0(target, index);
// added in gl4.5
private z_DisableVertexArrayAttrib_adr := GetFuncAdr('glDisableVertexArrayAttrib');
private z_DisableVertexArrayAttrib_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; index: UInt32)>(z_DisableVertexArrayAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32) :=
z_DisableVertexArrayAttrib_ovr_0(vaobj, index);
// added in gl2.0
private z_DisableVertexAttribArray_adr := GetFuncAdr('glDisableVertexAttribArray');
private z_DisableVertexAttribArray_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_DisableVertexAttribArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArray(index: UInt32) :=
z_DisableVertexAttribArray_ovr_0(index);
// added in gl4.3
private z_DispatchCompute_adr := GetFuncAdr('glDispatchCompute');
private z_DispatchCompute_ovr_0 := GetFuncOrNil&<procedure(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32)>(z_DispatchCompute_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchCompute(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32) :=
z_DispatchCompute_ovr_0(num_groups_x, num_groups_y, num_groups_z);
// added in gl4.3
private z_DispatchComputeIndirect_adr := GetFuncAdr('glDispatchComputeIndirect');
private z_DispatchComputeIndirect_ovr_0 := GetFuncOrNil&<procedure(indirect: IntPtr)>(z_DispatchComputeIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchComputeIndirect(indirect: IntPtr) :=
z_DispatchComputeIndirect_ovr_0(indirect);
// added in gl1.1
private static procedure z_DrawArrays_ovr_0(mode: PrimitiveType; first: Int32; count: Int32);
external 'opengl32.dll' name 'glDrawArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArrays(mode: PrimitiveType; first: Int32; count: Int32) :=
z_DrawArrays_ovr_0(mode, first, count);
// added in gl4.0
private z_DrawArraysIndirect_adr := GetFuncAdr('glDrawArraysIndirect');
private z_DrawArraysIndirect_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr)>(z_DrawArraysIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysIndirect(mode: PrimitiveType; indirect: IntPtr) :=
z_DrawArraysIndirect_ovr_0(mode, indirect);
// added in gl3.1
private z_DrawArraysInstanced_adr := GetFuncAdr('glDrawArraysInstanced');
private z_DrawArraysInstanced_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32)>(z_DrawArraysInstanced_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstanced(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32) :=
z_DrawArraysInstanced_ovr_0(mode, first, count, instancecount);
// added in gl4.2
private z_DrawArraysInstancedBaseInstance_adr := GetFuncAdr('glDrawArraysInstancedBaseInstance');
private z_DrawArraysInstancedBaseInstance_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32; baseinstance: UInt32)>(z_DrawArraysInstancedBaseInstance_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedBaseInstance(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32; baseinstance: UInt32) :=
z_DrawArraysInstancedBaseInstance_ovr_0(mode, first, count, instancecount, baseinstance);
// added in gl1.0
private static procedure z_DrawBuffer_ovr_0(buf: DrawBufferMode);
external 'opengl32.dll' name 'glDrawBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffer(buf: DrawBufferMode) :=
z_DrawBuffer_ovr_0(buf);
// added in gl2.0
private z_DrawBuffers_adr := GetFuncAdr('glDrawBuffers');
private z_DrawBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var bufs: DrawBufferMode)>(z_DrawBuffers_adr);
private z_DrawBuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; bufs: IntPtr)>(z_DrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; bufs: array of DrawBufferMode) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_DrawBuffers_ovr_0(n, bufs[0]) else
z_DrawBuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; var bufs: DrawBufferMode) :=
z_DrawBuffers_ovr_0(n, bufs);
private z_DrawBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; bufs: IntPtr)>(z_DrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; bufs: IntPtr) :=
z_DrawBuffers_ovr_2(n, bufs);
// added in gl1.1
private static procedure z_DrawElements_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr);
external 'opengl32.dll' name 'glDrawElements';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElements(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr) :=
z_DrawElements_ovr_0(mode, count, &type, indices);
// added in gl3.2
private z_DrawElementsBaseVertex_adr := GetFuncAdr('glDrawElementsBaseVertex');
private z_DrawElementsBaseVertex_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32)>(z_DrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsBaseVertex(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32) :=
z_DrawElementsBaseVertex_ovr_0(mode, count, &type, indices, basevertex);
// added in gl4.0
private z_DrawElementsIndirect_adr := GetFuncAdr('glDrawElementsIndirect');
private z_DrawElementsIndirect_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr)>(z_DrawElementsIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsIndirect(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr) :=
z_DrawElementsIndirect_ovr_0(mode, &type, indirect);
// added in gl3.1
private z_DrawElementsInstanced_adr := GetFuncAdr('glDrawElementsInstanced');
private z_DrawElementsInstanced_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32)>(z_DrawElementsInstanced_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstanced(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32) :=
z_DrawElementsInstanced_ovr_0(mode, count, &type, indices, instancecount);
// added in gl4.2
private z_DrawElementsInstancedBaseInstance_adr := GetFuncAdr('glDrawElementsInstancedBaseInstance');
private z_DrawElementsInstancedBaseInstance_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: PrimitiveType; indices: IntPtr; instancecount: Int32; baseinstance: UInt32)>(z_DrawElementsInstancedBaseInstance_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseInstance(mode: PrimitiveType; count: Int32; &type: PrimitiveType; indices: IntPtr; instancecount: Int32; baseinstance: UInt32) :=
z_DrawElementsInstancedBaseInstance_ovr_0(mode, count, &type, indices, instancecount, baseinstance);
// added in gl3.2
private z_DrawElementsInstancedBaseVertex_adr := GetFuncAdr('glDrawElementsInstancedBaseVertex');
private z_DrawElementsInstancedBaseVertex_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32)>(z_DrawElementsInstancedBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseVertex(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32) :=
z_DrawElementsInstancedBaseVertex_ovr_0(mode, count, &type, indices, instancecount, basevertex);
// added in gl4.2
private z_DrawElementsInstancedBaseVertexBaseInstance_adr := GetFuncAdr('glDrawElementsInstancedBaseVertexBaseInstance');
private z_DrawElementsInstancedBaseVertexBaseInstance_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32; baseinstance: UInt32)>(z_DrawElementsInstancedBaseVertexBaseInstance_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseVertexBaseInstance(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32; baseinstance: UInt32) :=
z_DrawElementsInstancedBaseVertexBaseInstance_ovr_0(mode, count, &type, indices, instancecount, basevertex, baseinstance);
// added in gl1.2
private z_DrawRangeElements_adr := GetFuncAdr('glDrawRangeElements');
private z_DrawRangeElements_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr)>(z_DrawRangeElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElements(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr) :=
z_DrawRangeElements_ovr_0(mode, start, &end, count, &type, indices);
// added in gl3.2
private z_DrawRangeElementsBaseVertex_adr := GetFuncAdr('glDrawRangeElementsBaseVertex');
private z_DrawRangeElementsBaseVertex_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32)>(z_DrawRangeElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementsBaseVertex(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32) :=
z_DrawRangeElementsBaseVertex_ovr_0(mode, start, &end, count, &type, indices, basevertex);
// added in gl4.0
private z_DrawTransformFeedback_adr := GetFuncAdr('glDrawTransformFeedback');
private z_DrawTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: TransformFeedbackName)>(z_DrawTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedback(mode: PrimitiveType; id: TransformFeedbackName) :=
z_DrawTransformFeedback_ovr_0(mode, id);
// added in gl4.2
private z_DrawTransformFeedbackInstanced_adr := GetFuncAdr('glDrawTransformFeedbackInstanced');
private z_DrawTransformFeedbackInstanced_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: TransformFeedbackName; instancecount: Int32)>(z_DrawTransformFeedbackInstanced_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackInstanced(mode: PrimitiveType; id: TransformFeedbackName; instancecount: Int32) :=
z_DrawTransformFeedbackInstanced_ovr_0(mode, id, instancecount);
// added in gl4.0
private z_DrawTransformFeedbackStream_adr := GetFuncAdr('glDrawTransformFeedbackStream');
private z_DrawTransformFeedbackStream_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32)>(z_DrawTransformFeedbackStream_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackStream(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32) :=
z_DrawTransformFeedbackStream_ovr_0(mode, id, stream);
// added in gl4.2
private z_DrawTransformFeedbackStreamInstanced_adr := GetFuncAdr('glDrawTransformFeedbackStreamInstanced');
private z_DrawTransformFeedbackStreamInstanced_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32; instancecount: Int32)>(z_DrawTransformFeedbackStreamInstanced_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackStreamInstanced(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32; instancecount: Int32) :=
z_DrawTransformFeedbackStreamInstanced_ovr_0(mode, id, stream, instancecount);
// added in gl1.0
private static procedure z_Enable_ovr_0(cap: EnableCap);
external 'opengl32.dll' name 'glEnable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Enable(cap: EnableCap) :=
z_Enable_ovr_0(cap);
// added in gl3.0
private z_Enablei_adr := GetFuncAdr('glEnablei');
private z_Enablei_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_Enablei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Enablei(target: EnableCap; index: UInt32) :=
z_Enablei_ovr_0(target, index);
// added in gl4.5
private z_EnableVertexArrayAttrib_adr := GetFuncAdr('glEnableVertexArrayAttrib');
private z_EnableVertexArrayAttrib_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; index: UInt32)>(z_EnableVertexArrayAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32) :=
z_EnableVertexArrayAttrib_ovr_0(vaobj, index);
// added in gl2.0
private z_EnableVertexAttribArray_adr := GetFuncAdr('glEnableVertexAttribArray');
private z_EnableVertexAttribArray_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_EnableVertexAttribArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArray(index: UInt32) :=
z_EnableVertexAttribArray_ovr_0(index);
// added in gl3.0
private z_EndConditionalRender_adr := GetFuncAdr('glEndConditionalRender');
private z_EndConditionalRender_ovr_0 := GetFuncOrNil&<procedure>(z_EndConditionalRender_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRender :=
z_EndConditionalRender_ovr_0;
// added in gl1.5
private z_EndQuery_adr := GetFuncAdr('glEndQuery');
private z_EndQuery_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget)>(z_EndQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQuery(target: QueryTarget) :=
z_EndQuery_ovr_0(target);
// added in gl4.0
private z_EndQueryIndexed_adr := GetFuncAdr('glEndQueryIndexed');
private z_EndQueryIndexed_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32)>(z_EndQueryIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQueryIndexed(target: QueryTarget; index: UInt32) :=
z_EndQueryIndexed_ovr_0(target, index);
// added in gl3.0
private z_EndTransformFeedback_adr := GetFuncAdr('glEndTransformFeedback');
private z_EndTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_EndTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedback :=
z_EndTransformFeedback_ovr_0;
// added in gl3.2
private z_FenceSync_adr := GetFuncAdr('glFenceSync');
private z_FenceSync_ovr_0 := GetFuncOrNil&<function(condition: SyncCondition; flags: DummyFlags): GLsync>(z_FenceSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FenceSync(condition: SyncCondition; flags: DummyFlags): GLsync :=
z_FenceSync_ovr_0(condition, flags);
// added in gl1.0
private static procedure z_Finish_ovr_0;
external 'opengl32.dll' name 'glFinish';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Finish :=
z_Finish_ovr_0;
// added in gl1.0
private static procedure z_Flush_ovr_0;
external 'opengl32.dll' name 'glFlush';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Flush :=
z_Flush_ovr_0;
// added in gl3.0
private z_FlushMappedBufferRange_adr := GetFuncAdr('glFlushMappedBufferRange');
private z_FlushMappedBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; length: IntPtr)>(z_FlushMappedBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr) :=
z_FlushMappedBufferRange_ovr_0(target, offset, length);
// added in gl4.5
private z_FlushMappedNamedBufferRange_adr := GetFuncAdr('glFlushMappedNamedBufferRange');
private z_FlushMappedNamedBufferRange_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName; offset: IntPtr; length: IntPtr)>(z_FlushMappedNamedBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedNamedBufferRange(buffer: BufferName; offset: IntPtr; length: IntPtr) :=
z_FlushMappedNamedBufferRange_ovr_0(buffer, offset, length);
// added in gl4.3
private z_FramebufferParameteri_adr := GetFuncAdr('glFramebufferParameteri');
private z_FramebufferParameteri_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32)>(z_FramebufferParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferParameteri(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32) :=
z_FramebufferParameteri_ovr_0(target, pname, param);
// added in gl3.0
private z_FramebufferRenderbuffer_adr := GetFuncAdr('glFramebufferRenderbuffer');
private z_FramebufferRenderbuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName)>(z_FramebufferRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferRenderbuffer(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_FramebufferRenderbuffer_ovr_0(target, attachment, _renderbuffertarget, renderbuffer);
// added in gl3.2
private z_FramebufferTexture_adr := GetFuncAdr('glFramebufferTexture');
private z_FramebufferTexture_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32)>(z_FramebufferTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32) :=
z_FramebufferTexture_ovr_0(target, attachment, texture, level);
// added in gl3.0
private z_FramebufferTexture1D_adr := GetFuncAdr('glFramebufferTexture1D');
private z_FramebufferTexture1D_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_FramebufferTexture1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture1D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture1D_ovr_0(target, attachment, textarget, texture, level);
// added in gl3.0
private z_FramebufferTexture2D_adr := GetFuncAdr('glFramebufferTexture2D');
private z_FramebufferTexture2D_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_FramebufferTexture2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture2D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture2D_ovr_0(target, attachment, textarget, texture, level);
// added in gl3.0
private z_FramebufferTexture3D_adr := GetFuncAdr('glFramebufferTexture3D');
private z_FramebufferTexture3D_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32)>(z_FramebufferTexture3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture3D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32) :=
z_FramebufferTexture3D_ovr_0(target, attachment, textarget, texture, level, zoffset);
// added in gl3.0
private z_FramebufferTextureLayer_adr := GetFuncAdr('glFramebufferTextureLayer');
private z_FramebufferTextureLayer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32)>(z_FramebufferTextureLayer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayer(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32) :=
z_FramebufferTextureLayer_ovr_0(target, attachment, texture, level, layer);
// added in gl1.0
private static procedure z_FrontFace_ovr_0(mode: FrontFaceDirection);
external 'opengl32.dll' name 'glFrontFace';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrontFace(mode: FrontFaceDirection) :=
z_FrontFace_ovr_0(mode);
// added in gl1.5
private z_GenBuffers_adr := GetFuncAdr('glGenBuffers');
private z_GenBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: BufferName)>(z_GenBuffers_adr);
private z_GenBuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_GenBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; buffers: array of BufferName) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_GenBuffers_ovr_0(n, buffers[0]) else
z_GenBuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; var buffers: BufferName) :=
z_GenBuffers_ovr_0(n, buffers);
private z_GenBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_GenBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; buffers: IntPtr) :=
z_GenBuffers_ovr_2(n, buffers);
// added in gl3.0
private z_GenerateMipmap_adr := GetFuncAdr('glGenerateMipmap');
private z_GenerateMipmap_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget)>(z_GenerateMipmap_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMipmap(target: TextureTarget) :=
z_GenerateMipmap_ovr_0(target);
// added in gl4.5
private z_GenerateTextureMipmap_adr := GetFuncAdr('glGenerateTextureMipmap');
private z_GenerateTextureMipmap_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName)>(z_GenerateTextureMipmap_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateTextureMipmap(texture: TextureName) :=
z_GenerateTextureMipmap_ovr_0(texture);
// added in gl3.0
private z_GenFramebuffers_adr := GetFuncAdr('glGenFramebuffers');
private z_GenFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_GenFramebuffers_adr);
private z_GenFramebuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_GenFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_GenFramebuffers_ovr_0(n, framebuffers[0]) else
z_GenFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_GenFramebuffers_ovr_0(n, framebuffers);
private z_GenFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_GenFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_GenFramebuffers_ovr_2(n, framebuffers);
// added in gl4.1
private z_GenProgramPipelines_adr := GetFuncAdr('glGenProgramPipelines');
private z_GenProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_GenProgramPipelines_adr);
private z_GenProgramPipelines_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_GenProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_GenProgramPipelines_ovr_0(n, pipelines[0]) else
z_GenProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_GenProgramPipelines_ovr_0(n, pipelines);
private z_GenProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_GenProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_GenProgramPipelines_ovr_2(n, pipelines);
// added in gl1.5
private z_GenQueries_adr := GetFuncAdr('glGenQueries');
private z_GenQueries_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenQueries_adr);
private z_GenQueries_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenQueries_ovr_0(n, ids[0]) else
z_GenQueries_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; var ids: UInt32) :=
z_GenQueries_ovr_0(n, ids);
private z_GenQueries_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; ids: IntPtr) :=
z_GenQueries_ovr_2(n, ids);
// added in gl3.0
private z_GenRenderbuffers_adr := GetFuncAdr('glGenRenderbuffers');
private z_GenRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_GenRenderbuffers_adr);
private z_GenRenderbuffers_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_GenRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_GenRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_GenRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_GenRenderbuffers_ovr_0(n, renderbuffers);
private z_GenRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_GenRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_GenRenderbuffers_ovr_2(n, renderbuffers);
// added in gl3.3
private z_GenSamplers_adr := GetFuncAdr('glGenSamplers');
private z_GenSamplers_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var samplers: UInt32)>(z_GenSamplers_adr);
private z_GenSamplers_ovr_0_anh001 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_GenSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_GenSamplers_ovr_0(count, samplers[0]) else
z_GenSamplers_ovr_0_anh001(count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; var samplers: UInt32) :=
z_GenSamplers_ovr_0(count, samplers);
private z_GenSamplers_ovr_2 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_GenSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: IntPtr) :=
z_GenSamplers_ovr_2(count, samplers);
// added in gl1.1
private static procedure z_GenTextures_ovr_0(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glGenTextures';
private static procedure z_GenTextures_ovr_0_anh001(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glGenTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_GenTextures_ovr_0(n, textures[0]) else
z_GenTextures_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; var textures: UInt32) :=
z_GenTextures_ovr_0(n, textures);
private static procedure z_GenTextures_ovr_2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glGenTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; textures: IntPtr) :=
z_GenTextures_ovr_2(n, textures);
// added in gl4.0
private z_GenTransformFeedbacks_adr := GetFuncAdr('glGenTransformFeedbacks');
private z_GenTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenTransformFeedbacks_adr);
private z_GenTransformFeedbacks_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenTransformFeedbacks_ovr_0(n, ids[0]) else
z_GenTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_GenTransformFeedbacks_ovr_0(n, ids);
private z_GenTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_GenTransformFeedbacks_ovr_2(n, ids);
// added in gl3.0
private z_GenVertexArrays_adr := GetFuncAdr('glGenVertexArrays');
private z_GenVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_GenVertexArrays_adr);
private z_GenVertexArrays_ovr_0_anh001 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_GenVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_GenVertexArrays_ovr_0(n, arrays[0]) else
z_GenVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; var arrays: UInt32) :=
z_GenVertexArrays_ovr_0(n, arrays);
private z_GenVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_GenVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: IntPtr) :=
z_GenVertexArrays_ovr_2(n, arrays);
// added in gl4.2
private z_GetActiveAtomicCounterBufferiv_adr := GetFuncAdr('glGetActiveAtomicCounterBufferiv');
private z_GetActiveAtomicCounterBufferiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32)>(z_GetActiveAtomicCounterBufferiv_adr);
private z_GetActiveAtomicCounterBufferiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr)>(z_GetActiveAtomicCounterBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms[0]) else
z_GetActiveAtomicCounterBufferiv_ovr_0_anh00001(&program, bufferIndex, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32) :=
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms);
private z_GetActiveAtomicCounterBufferiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr)>(z_GetActiveAtomicCounterBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr) :=
z_GetActiveAtomicCounterBufferiv_ovr_2(&program, bufferIndex, pname, ¶ms);
// added in gl2.0
private z_GetActiveAttrib_adr := GetFuncAdr('glGetActiveAttrib');
private z_GetActiveAttrib_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_0_anh00001110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000010(&program, index, bufSize, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000110(&program, index, bufSize, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00001110(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private z_GetActiveAttrib_ovr_1_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_1_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_1_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveAttrib_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveAttrib_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetActiveAttrib_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_2_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_2_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_2_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveAttrib_ovr_2_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveAttrib_ovr_2_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetActiveAttrib_ovr_3_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_3_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetActiveAttrib_ovr_4_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveAttrib_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveAttrib_ovr_5_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveAttrib_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveAttrib_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_6_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_6_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_6_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveAttrib_ovr_6_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveAttrib_ovr_6_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetActiveAttrib_ovr_7_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveAttrib_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveAttrib_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_8_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttrib_ovr_8(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveAttrib_ovr_8_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveAttrib_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveAttrib_ovr_2_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveAttrib_ovr_0_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveAttrib_ovr_6_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttrib_ovr_8(&program, index, bufSize, length, size, &type, name);
private z_GetActiveAttrib_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_18_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_18_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_18_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveAttrib_ovr_18_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveAttrib_ovr_18_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
private z_GetActiveAttrib_ovr_19_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveAttrib_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
private z_GetActiveAttrib_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_20_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttrib_ovr_20(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveAttrib_ovr_20_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveAttrib_ovr_18_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttrib_ovr_20(&program, index, bufSize, length, size, &type, name);
private z_GetActiveAttrib_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttrib_adr);
private z_GetActiveAttrib_ovr_24_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttrib_ovr_24(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveAttrib_ovr_24_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttrib_ovr_24(&program, index, bufSize, length, size, &type, name);
private z_GetActiveAttrib_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttrib_ovr_26(&program, index, bufSize, length, size, &type, name);
// added in gl4.0
private z_GetActiveSubroutineName_adr := GetFuncAdr('glGetActiveSubroutineName');
private z_GetActiveSubroutineName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr)>(z_GetActiveSubroutineName_adr);
private z_GetActiveSubroutineName_ovr_0_anh0000010 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetActiveSubroutineName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length[0], name) else
z_GetActiveSubroutineName_ovr_0_anh0000010(&program, _shadertype, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length, name);
private z_GetActiveSubroutineName_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetActiveSubroutineName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetActiveSubroutineName_ovr_2(&program, _shadertype, index, bufSize, length, name);
// added in gl4.0
private z_GetActiveSubroutineUniformiv_adr := GetFuncAdr('glGetActiveSubroutineUniformiv');
private z_GetActiveSubroutineUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32)>(z_GetActiveSubroutineUniformiv_adr);
private z_GetActiveSubroutineUniformiv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr)>(z_GetActiveSubroutineUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values[0]) else
z_GetActiveSubroutineUniformiv_ovr_0_anh000001(&program, _shadertype, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32) :=
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values);
private z_GetActiveSubroutineUniformiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr)>(z_GetActiveSubroutineUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr) :=
z_GetActiveSubroutineUniformiv_ovr_2(&program, _shadertype, index, pname, values);
// added in gl4.0
private z_GetActiveSubroutineUniformName_adr := GetFuncAdr('glGetActiveSubroutineUniformName');
private z_GetActiveSubroutineUniformName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr)>(z_GetActiveSubroutineUniformName_adr);
private z_GetActiveSubroutineUniformName_ovr_0_anh0000010 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetActiveSubroutineUniformName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length[0], name) else
z_GetActiveSubroutineUniformName_ovr_0_anh0000010(&program, _shadertype, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length, name);
private z_GetActiveSubroutineUniformName_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetActiveSubroutineUniformName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetActiveSubroutineUniformName_ovr_2(&program, _shadertype, index, bufSize, length, name);
// added in gl2.0
private z_GetActiveUniform_adr := GetFuncAdr('glGetActiveUniform');
private z_GetActiveUniform_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_0_anh00001110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000010(&program, index, bufSize, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000110(&program, index, bufSize, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type[0], name) else
z_GetActiveUniform_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00001110(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private z_GetActiveUniform_ovr_1_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_1_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_1_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveUniform_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveUniform_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetActiveUniform_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_2_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_2_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_2_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_2(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveUniform_ovr_2_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveUniform_ovr_2_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetActiveUniform_ovr_3_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_3_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetActiveUniform_ovr_4_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveUniform_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveUniform_ovr_5_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniform_ovr_2(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveUniform_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveUniform_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_6_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_6_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_6_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_6(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveUniform_ovr_6_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveUniform_ovr_6_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetActiveUniform_ovr_7_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniform_ovr_6(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveUniform_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetActiveUniform_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_8_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniform_ovr_8(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveUniform_ovr_8_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveUniform_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_2(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveUniform_ovr_2_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveUniform_ovr_0_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniform_ovr_2(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_6(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveUniform_ovr_6_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniform_ovr_6(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniform_ovr_8(&program, index, bufSize, length, size, &type, name);
private z_GetActiveUniform_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_18_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_18_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_18_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveUniform_ovr_18_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveUniform_ovr_18_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
private z_GetActiveUniform_ovr_19_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveUniform_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
private z_GetActiveUniform_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_20_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniform_ovr_20(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveUniform_ovr_20_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveUniform_ovr_18_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniform_ovr_20(&program, index, bufSize, length, size, &type, name);
private z_GetActiveUniform_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniform_adr);
private z_GetActiveUniform_ovr_24_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniform_ovr_24(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveUniform_ovr_24_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniform_ovr_24(&program, index, bufSize, length, size, &type, name);
private z_GetActiveUniform_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniform_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniform_ovr_26(&program, index, bufSize, length, size, &type, name);
// added in gl3.1
private z_GetActiveUniformBlockiv_adr := GetFuncAdr('glGetActiveUniformBlockiv');
private z_GetActiveUniformBlockiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32)>(z_GetActiveUniformBlockiv_adr);
private z_GetActiveUniformBlockiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr)>(z_GetActiveUniformBlockiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms[0]) else
z_GetActiveUniformBlockiv_ovr_0_anh00001(&program, uniformBlockIndex, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32) :=
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms);
private z_GetActiveUniformBlockiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr)>(z_GetActiveUniformBlockiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr) :=
z_GetActiveUniformBlockiv_ovr_2(&program, uniformBlockIndex, pname, ¶ms);
// added in gl3.1
private z_GetActiveUniformBlockName_adr := GetFuncAdr('glGetActiveUniformBlockName');
private z_GetActiveUniformBlockName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr)>(z_GetActiveUniformBlockName_adr);
private z_GetActiveUniformBlockName_ovr_0_anh000010 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr)>(z_GetActiveUniformBlockName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: array of Int32; uniformBlockName: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length[0], uniformBlockName) else
z_GetActiveUniformBlockName_ovr_0_anh000010(&program, uniformBlockIndex, bufSize, IntPtr.Zero, uniformBlockName);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr) :=
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
private z_GetActiveUniformBlockName_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr)>(z_GetActiveUniformBlockName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr) :=
z_GetActiveUniformBlockName_ovr_2(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
// added in gl3.1
private z_GetActiveUniformName_adr := GetFuncAdr('glGetActiveUniformName');
private z_GetActiveUniformName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr)>(z_GetActiveUniformName_adr);
private z_GetActiveUniformName_ovr_0_anh000010 := GetFuncOrNil&<procedure(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr)>(z_GetActiveUniformName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: array of Int32; uniformName: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length[0], uniformName) else
z_GetActiveUniformName_ovr_0_anh000010(&program, uniformIndex, bufSize, IntPtr.Zero, uniformName);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr) :=
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length, uniformName);
private z_GetActiveUniformName_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr)>(z_GetActiveUniformName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr) :=
z_GetActiveUniformName_ovr_2(&program, uniformIndex, bufSize, length, uniformName);
// added in gl3.1
private z_GetActiveUniformsiv_adr := GetFuncAdr('glGetActiveUniformsiv');
private z_GetActiveUniformsiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32)>(z_GetActiveUniformsiv_adr);
private z_GetActiveUniformsiv_ovr_0_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32)>(z_GetActiveUniformsiv_adr);
private z_GetActiveUniformsiv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
private z_GetActiveUniformsiv_ovr_0_anh000101 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; ¶ms: array of Int32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000001(&program, uniformCount, uniformIndices[0], pname, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000101(&program, uniformCount, IntPtr.Zero, pname, IntPtr.Zero);
private z_GetActiveUniformsiv_ovr_1_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; var ¶ms: Int32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms) else
z_GetActiveUniformsiv_ovr_0_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms);
private z_GetActiveUniformsiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
private z_GetActiveUniformsiv_ovr_2_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; ¶ms: IntPtr) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices[0], pname, ¶ms) else
z_GetActiveUniformsiv_ovr_2_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000001(&program, uniformCount, uniformIndices, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32) :=
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr) :=
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices, pname, ¶ms);
private z_GetActiveUniformsiv_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32)>(z_GetActiveUniformsiv_adr);
private z_GetActiveUniformsiv_ovr_6_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_6_anh000001(&program, uniformCount, uniformIndices, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32) :=
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms);
private z_GetActiveUniformsiv_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr) :=
z_GetActiveUniformsiv_ovr_8(&program, uniformCount, uniformIndices, pname, ¶ms);
// added in gl2.0
private z_GetAttachedShaders_adr := GetFuncAdr('glGetAttachedShaders');
private z_GetAttachedShaders_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; var count: Int32; var shaders: UInt32)>(z_GetAttachedShaders_adr);
private z_GetAttachedShaders_ovr_0_anh00010 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; var shaders: UInt32)>(z_GetAttachedShaders_adr);
private z_GetAttachedShaders_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; var count: Int32; shaders: IntPtr)>(z_GetAttachedShaders_adr);
private z_GetAttachedShaders_ovr_0_anh00011 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: IntPtr)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; shaders: array of UInt32) :=
if (count<>nil) and (count.Length<>0) then
if (shaders<>nil) and (shaders.Length<>0) then
z_GetAttachedShaders_ovr_0(&program, maxCount, count[0], shaders[0]) else
z_GetAttachedShaders_ovr_0_anh00001(&program, maxCount, count[0], IntPtr.Zero) else
if (shaders<>nil) and (shaders.Length<>0) then
z_GetAttachedShaders_ovr_0_anh00010(&program, maxCount, IntPtr.Zero, shaders[0]) else
z_GetAttachedShaders_ovr_0_anh00011(&program, maxCount, IntPtr.Zero, IntPtr.Zero);
private z_GetAttachedShaders_ovr_1_anh00010 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; var shaders: UInt32)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; var shaders: UInt32) :=
if (count<>nil) and (count.Length<>0) then
z_GetAttachedShaders_ovr_0(&program, maxCount, count[0], shaders) else
z_GetAttachedShaders_ovr_0_anh00010(&program, maxCount, IntPtr.Zero, shaders);
private z_GetAttachedShaders_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; var count: Int32; shaders: IntPtr)>(z_GetAttachedShaders_adr);
private z_GetAttachedShaders_ovr_2_anh00010 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: IntPtr)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; shaders: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_GetAttachedShaders_ovr_2(&program, maxCount, count[0], shaders) else
z_GetAttachedShaders_ovr_2_anh00010(&program, maxCount, IntPtr.Zero, shaders);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; shaders: array of UInt32) :=
if (shaders<>nil) and (shaders.Length<>0) then
z_GetAttachedShaders_ovr_0(&program, maxCount, count, shaders[0]) else
z_GetAttachedShaders_ovr_0_anh00001(&program, maxCount, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; var shaders: UInt32) :=
z_GetAttachedShaders_ovr_0(&program, maxCount, count, shaders);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; shaders: IntPtr) :=
z_GetAttachedShaders_ovr_2(&program, maxCount, count, shaders);
private z_GetAttachedShaders_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; var shaders: UInt32)>(z_GetAttachedShaders_adr);
private z_GetAttachedShaders_ovr_6_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: IntPtr)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: array of UInt32) :=
if (shaders<>nil) and (shaders.Length<>0) then
z_GetAttachedShaders_ovr_6(&program, maxCount, count, shaders[0]) else
z_GetAttachedShaders_ovr_6_anh00001(&program, maxCount, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: IntPtr; var shaders: UInt32) :=
z_GetAttachedShaders_ovr_6(&program, maxCount, count, shaders);
private z_GetAttachedShaders_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: IntPtr)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: IntPtr; shaders: IntPtr) :=
z_GetAttachedShaders_ovr_8(&program, maxCount, count, shaders);
// added in gl2.0
private z_GetAttribLocation_adr := GetFuncAdr('glGetAttribLocation');
private z_GetAttribLocation_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; name: IntPtr): Int32>(z_GetAttribLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetAttribLocation(&program: ProgramName; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetAttribLocation_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetAttribLocation(&program: ProgramName; name: IntPtr): Int32 :=
z_GetAttribLocation_ovr_0(&program, name);
// added in gl3.0
private z_GetBooleani_v_adr := GetFuncAdr('glGetBooleani_v');
private z_GetBooleani_v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleani_v_adr);
private z_GetBooleani_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetBooleani_v_ovr_0(target, index, data[0]) else
z_GetBooleani_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; var data: boolean) :=
z_GetBooleani_v_ovr_0(target, index, data);
private z_GetBooleani_v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
z_GetBooleani_v_ovr_2(target, index, data);
// added in gl1.0
private static procedure z_GetBooleanv_ovr_0(pname: GetPName; var data: boolean);
external 'opengl32.dll' name 'glGetBooleanv';
private static procedure z_GetBooleanv_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetBooleanv_ovr_0(pname, data[0]) else
z_GetBooleanv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; var data: boolean) :=
z_GetBooleanv_ovr_0(pname, data);
private static procedure z_GetBooleanv_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; data: IntPtr) :=
z_GetBooleanv_ovr_2(pname, data);
// added in gl3.2
private z_GetBufferParameteri64v_adr := GetFuncAdr('glGetBufferParameteri64v');
private z_GetBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int64)>(z_GetBufferParameteri64v_adr);
private z_GetBufferParameteri64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr)>(z_GetBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferParameteri64v_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferParameteri64v_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int64) :=
z_GetBufferParameteri64v_ovr_0(target, pname, ¶ms);
private z_GetBufferParameteri64v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr)>(z_GetBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr) :=
z_GetBufferParameteri64v_ovr_2(target, pname, ¶ms);
// added in gl1.5
private z_GetBufferParameteriv_adr := GetFuncAdr('glGetBufferParameteriv');
private z_GetBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32)>(z_GetBufferParameteriv_adr);
private z_GetBufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr)>(z_GetBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32) :=
z_GetBufferParameteriv_ovr_0(target, pname, ¶ms);
private z_GetBufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr)>(z_GetBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr) :=
z_GetBufferParameteriv_ovr_2(target, pname, ¶ms);
// added in gl1.5
private z_GetBufferPointerv_adr := GetFuncAdr('glGetBufferPointerv');
private z_GetBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr)>(z_GetBufferPointerv_adr);
private z_GetBufferPointerv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: IntPtr)>(z_GetBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferPointerv_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferPointerv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr) :=
z_GetBufferPointerv_ovr_0(target, pname, ¶ms);
private z_GetBufferPointerv_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer)>(z_GetBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer) :=
z_GetBufferPointerv_ovr_2(target, pname, ¶ms);
// added in gl1.5
private z_GetBufferSubData_adr := GetFuncAdr('glGetBufferSubData');
private z_GetBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubData(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_GetBufferSubData_ovr_0(target, offset, size, data);
// added in gl1.3
private z_GetCompressedTexImage_adr := GetFuncAdr('glGetCompressedTexImage');
private z_GetCompressedTexImage_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; img: IntPtr)>(z_GetCompressedTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTexImage(target: TextureTarget; level: Int32; img: IntPtr) :=
z_GetCompressedTexImage_ovr_0(target, level, img);
// added in gl4.5
private z_GetCompressedTextureImage_adr := GetFuncAdr('glGetCompressedTextureImage');
private z_GetCompressedTextureImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; bufSize: Int32; pixels: IntPtr)>(z_GetCompressedTextureImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureImage(texture: UInt32; level: Int32; bufSize: Int32; pixels: IntPtr) :=
z_GetCompressedTextureImage_ovr_0(texture, level, bufSize, pixels);
// added in gl4.5
private z_GetCompressedTextureSubImage_adr := GetFuncAdr('glGetCompressedTextureSubImage');
private z_GetCompressedTextureSubImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; bufSize: Int32; pixels: IntPtr)>(z_GetCompressedTextureSubImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; bufSize: Int32; pixels: IntPtr) :=
z_GetCompressedTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
// added in gl4.3
private z_GetDebugMessageLog_adr := GetFuncAdr('glGetDebugMessageLog');
private z_GetDebugMessageLog_ovr_0 := GetFuncOrNil&<function(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32>(z_GetDebugMessageLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLog(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLog_ovr_0(count, bufSize, sources, types, ids, severities, lengths, messageLog);
private z_GetDebugMessageLog_ovr_1 := GetFuncOrNil&<function(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32>(z_GetDebugMessageLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLog(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLog_ovr_1(count, bufSize, sources, types, ids, severities, lengths, messageLog);
// added in gl4.1
private z_GetDoublei_v_adr := GetFuncAdr('glGetDoublei_v');
private z_GetDoublei_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: real)>(z_GetDoublei_v_adr);
private z_GetDoublei_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetDoublei_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; data: array of real) :=
if (data<>nil) and (data.Length<>0) then
z_GetDoublei_v_ovr_0(target, index, data[0]) else
z_GetDoublei_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; var data: real) :=
z_GetDoublei_v_ovr_0(target, index, data);
private z_GetDoublei_v_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetDoublei_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetDoublei_v_ovr_2(target, index, data);
// added in gl1.0
private static procedure z_GetDoublev_ovr_0(pname: GetPName; var data: real);
external 'opengl32.dll' name 'glGetDoublev';
private static procedure z_GetDoublev_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetDoublev';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; data: array of real) :=
if (data<>nil) and (data.Length<>0) then
z_GetDoublev_ovr_0(pname, data[0]) else
z_GetDoublev_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; var data: real) :=
z_GetDoublev_ovr_0(pname, data);
private static procedure z_GetDoublev_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetDoublev';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; data: IntPtr) :=
z_GetDoublev_ovr_2(pname, data);
// added in gl1.0
private static function z_GetError_ovr_0: ErrorCode;
external 'opengl32.dll' name 'glGetError';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetError: ErrorCode :=
z_GetError_ovr_0;
// added in gl4.1
private z_GetFloati_v_adr := GetFuncAdr('glGetFloati_v');
private z_GetFloati_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: single)>(z_GetFloati_v_adr);
private z_GetFloati_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetFloati_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetFloati_v_ovr_0(target, index, data[0]) else
z_GetFloati_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; var data: single) :=
z_GetFloati_v_ovr_0(target, index, data);
private z_GetFloati_v_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetFloati_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetFloati_v_ovr_2(target, index, data);
// added in gl1.0
private static procedure z_GetFloatv_ovr_0(pname: GetPName; var data: single);
external 'opengl32.dll' name 'glGetFloatv';
private static procedure z_GetFloatv_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetFloatv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetFloatv_ovr_0(pname, data[0]) else
z_GetFloatv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; var data: single) :=
z_GetFloatv_ovr_0(pname, data);
private static procedure z_GetFloatv_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetFloatv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; data: IntPtr) :=
z_GetFloatv_ovr_2(pname, data);
// added in gl3.3
private z_GetFragDataIndex_adr := GetFuncAdr('glGetFragDataIndex');
private z_GetFragDataIndex_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; name: IntPtr): Int32>(z_GetFragDataIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataIndex(&program: ProgramName; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetFragDataIndex_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataIndex(&program: ProgramName; name: IntPtr): Int32 :=
z_GetFragDataIndex_ovr_0(&program, name);
// added in gl3.0
private z_GetFragDataLocation_adr := GetFuncAdr('glGetFragDataLocation');
private z_GetFragDataLocation_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; name: IntPtr): Int32>(z_GetFragDataLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataLocation(&program: ProgramName; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetFragDataLocation_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataLocation(&program: ProgramName; name: IntPtr): Int32 :=
z_GetFragDataLocation_ovr_0(&program, name);
// added in gl3.0
private z_GetFramebufferAttachmentParameteriv_adr := GetFuncAdr('glGetFramebufferAttachmentParameteriv');
private z_GetFramebufferAttachmentParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferAttachmentParameteriv_adr);
private z_GetFramebufferAttachmentParameteriv_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms[0]) else
z_GetFramebufferAttachmentParameteriv_ovr_0_anh00001(target, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms);
private z_GetFramebufferAttachmentParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferAttachmentParameteriv_ovr_2(target, attachment, pname, ¶ms);
// added in gl4.3
private z_GetFramebufferParameteriv_adr := GetFuncAdr('glGetFramebufferParameteriv');
private z_GetFramebufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferParameteriv_adr);
private z_GetFramebufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetFramebufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms);
private z_GetFramebufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferParameteriv_ovr_2(target, pname, ¶ms);
// added in gl4.5
private z_GetGraphicsResetStatus_adr := GetFuncAdr('glGetGraphicsResetStatus');
private z_GetGraphicsResetStatus_ovr_0 := GetFuncOrNil&<function: GraphicsResetStatus>(z_GetGraphicsResetStatus_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetGraphicsResetStatus: GraphicsResetStatus :=
z_GetGraphicsResetStatus_ovr_0;
// added in gl3.2
private z_GetInteger64i_v_adr := GetFuncAdr('glGetInteger64i_v');
private z_GetInteger64i_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int64)>(z_GetInteger64i_v_adr);
private z_GetInteger64i_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetInteger64i_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64i_v(target: DummyEnum; index: UInt32; data: array of Int64) :=
if (data<>nil) and (data.Length<>0) then
z_GetInteger64i_v_ovr_0(target, index, data[0]) else
z_GetInteger64i_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64i_v(target: DummyEnum; index: UInt32; var data: Int64) :=
z_GetInteger64i_v_ovr_0(target, index, data);
private z_GetInteger64i_v_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetInteger64i_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64i_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetInteger64i_v_ovr_2(target, index, data);
// added in gl3.2
private z_GetInteger64v_adr := GetFuncAdr('glGetInteger64v');
private z_GetInteger64v_ovr_0 := GetFuncOrNil&<procedure(pname: GetPName; var data: Int64)>(z_GetInteger64v_adr);
private z_GetInteger64v_ovr_0_anh001 := GetFuncOrNil&<procedure(pname: GetPName; data: IntPtr)>(z_GetInteger64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: array of Int64) :=
if (data<>nil) and (data.Length<>0) then
z_GetInteger64v_ovr_0(pname, data[0]) else
z_GetInteger64v_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; var data: Int64) :=
z_GetInteger64v_ovr_0(pname, data);
private z_GetInteger64v_ovr_2 := GetFuncOrNil&<procedure(pname: GetPName; data: IntPtr)>(z_GetInteger64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: IntPtr) :=
z_GetInteger64v_ovr_2(pname, data);
// added in gl3.0
private z_GetIntegeri_v_adr := GetFuncAdr('glGetIntegeri_v');
private z_GetIntegeri_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int32)>(z_GetIntegeri_v_adr);
private z_GetIntegeri_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetIntegeri_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetIntegeri_v_ovr_0(target, index, data[0]) else
z_GetIntegeri_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; var data: Int32) :=
z_GetIntegeri_v_ovr_0(target, index, data);
private z_GetIntegeri_v_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetIntegeri_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetIntegeri_v_ovr_2(target, index, data);
// added in gl1.0
private static procedure z_GetIntegerv_ovr_0(pname: GetPName; var data: Int32);
external 'opengl32.dll' name 'glGetIntegerv';
private static procedure z_GetIntegerv_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetIntegerv_ovr_0(pname, data[0]) else
z_GetIntegerv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; var data: Int32) :=
z_GetIntegerv_ovr_0(pname, data);
private static procedure z_GetIntegerv_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; data: IntPtr) :=
z_GetIntegerv_ovr_2(pname, data);
// added in gl4.3
private z_GetInternalformati64v_adr := GetFuncAdr('glGetInternalformati64v');
private z_GetInternalformati64v_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64)>(z_GetInternalformati64v_adr);
private z_GetInternalformati64v_ovr_0_anh000001 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr)>(z_GetInternalformati64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms[0]) else
z_GetInternalformati64v_ovr_0_anh000001(target, _internalformat, pname, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64) :=
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms);
private z_GetInternalformati64v_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr)>(z_GetInternalformati64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr) :=
z_GetInternalformati64v_ovr_2(target, _internalformat, pname, count, ¶ms);
// added in gl4.2
private z_GetInternalformativ_adr := GetFuncAdr('glGetInternalformativ');
private z_GetInternalformativ_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32)>(z_GetInternalformativ_adr);
private z_GetInternalformativ_ovr_0_anh000001 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr)>(z_GetInternalformativ_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms[0]) else
z_GetInternalformativ_ovr_0_anh000001(target, _internalformat, pname, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32) :=
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms);
private z_GetInternalformativ_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr)>(z_GetInternalformativ_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr) :=
z_GetInternalformativ_ovr_2(target, _internalformat, pname, count, ¶ms);
// added in gl3.2
private z_GetMultisamplefv_adr := GetFuncAdr('glGetMultisamplefv');
private z_GetMultisamplefv_ovr_0 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; var val: single)>(z_GetMultisamplefv_adr);
private z_GetMultisamplefv_ovr_0_anh0001 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr)>(z_GetMultisamplefv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; val: array of single) :=
if (val<>nil) and (val.Length<>0) then
z_GetMultisamplefv_ovr_0(pname, index, val[0]) else
z_GetMultisamplefv_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; var val: single) :=
z_GetMultisamplefv_ovr_0(pname, index, val);
private z_GetMultisamplefv_ovr_2 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr)>(z_GetMultisamplefv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr) :=
z_GetMultisamplefv_ovr_2(pname, index, val);
// added in gl4.5
private z_GetNamedBufferParameteri64v_adr := GetFuncAdr('glGetNamedBufferParameteri64v');
private z_GetNamedBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64)>(z_GetNamedBufferParameteri64v_adr);
private z_GetNamedBufferParameteri64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameteri64v_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64) :=
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms);
private z_GetNamedBufferParameteri64v_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameteri64v_ovr_2(buffer, pname, ¶ms);
// added in gl4.5
private z_GetNamedBufferParameteriv_adr := GetFuncAdr('glGetNamedBufferParameteriv');
private z_GetNamedBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32)>(z_GetNamedBufferParameteriv_adr);
private z_GetNamedBufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameteriv_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32) :=
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms);
private z_GetNamedBufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameteriv_ovr_2(buffer, pname, ¶ms);
// added in gl4.5
private z_GetNamedBufferPointerv_adr := GetFuncAdr('glGetNamedBufferPointerv');
private z_GetNamedBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr)>(z_GetNamedBufferPointerv_adr);
private z_GetNamedBufferPointerv_ovr_0_anh0001 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferPointerv_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr) :=
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms);
private z_GetNamedBufferPointerv_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer)>(z_GetNamedBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer) :=
z_GetNamedBufferPointerv_ovr_2(buffer, pname, ¶ms);
// added in gl4.5
private z_GetNamedBufferSubData_adr := GetFuncAdr('glGetNamedBufferSubData');
private z_GetNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_GetNamedBufferSubData_ovr_0(buffer, offset, size, data);
// added in gl4.5
private z_GetNamedFramebufferAttachmentParameteriv_adr := GetFuncAdr('glGetNamedFramebufferAttachmentParameteriv');
private z_GetNamedFramebufferAttachmentParameteriv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetNamedFramebufferAttachmentParameteriv_adr);
private z_GetNamedFramebufferAttachmentParameteriv_ovr_0_anh00001 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetNamedFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms[0]) else
z_GetNamedFramebufferAttachmentParameteriv_ovr_0_anh00001(framebuffer, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms);
private z_GetNamedFramebufferAttachmentParameteriv_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetNamedFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetNamedFramebufferAttachmentParameteriv_ovr_2(framebuffer, attachment, pname, ¶ms);
// added in gl4.5
private z_GetNamedFramebufferParameteriv_adr := GetFuncAdr('glGetNamedFramebufferParameteriv');
private z_GetNamedFramebufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32)>(z_GetNamedFramebufferParameteriv_adr);
private z_GetNamedFramebufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr)>(z_GetNamedFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param[0]) else
z_GetNamedFramebufferParameteriv_ovr_0_anh0001(framebuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32) :=
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param);
private z_GetNamedFramebufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr)>(z_GetNamedFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr) :=
z_GetNamedFramebufferParameteriv_ovr_2(framebuffer, pname, param);
// added in gl4.5
private z_GetNamedRenderbufferParameteriv_adr := GetFuncAdr('glGetNamedRenderbufferParameteriv');
private z_GetNamedRenderbufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetNamedRenderbufferParameteriv_adr);
private z_GetNamedRenderbufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetNamedRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms[0]) else
z_GetNamedRenderbufferParameteriv_ovr_0_anh0001(renderbuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms);
private z_GetNamedRenderbufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetNamedRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetNamedRenderbufferParameteriv_ovr_2(renderbuffer, pname, ¶ms);
// added in gl4.5
private z_GetnColorTable_adr := GetFuncAdr('glGetnColorTable');
private z_GetnColorTable_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr)>(z_GetnColorTable_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnColorTable(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr) :=
z_GetnColorTable_ovr_0(target, format, &type, bufSize, table);
// added in gl4.5
private z_GetnCompressedTexImage_adr := GetFuncAdr('glGetnCompressedTexImage');
private z_GetnCompressedTexImage_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; lod: Int32; bufSize: Int32; pixels: IntPtr)>(z_GetnCompressedTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnCompressedTexImage(target: TextureTarget; lod: Int32; bufSize: Int32; pixels: IntPtr) :=
z_GetnCompressedTexImage_ovr_0(target, lod, bufSize, pixels);
// added in gl4.5
private z_GetnConvolutionFilter_adr := GetFuncAdr('glGetnConvolutionFilter');
private z_GetnConvolutionFilter_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr)>(z_GetnConvolutionFilter_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnConvolutionFilter(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr) :=
z_GetnConvolutionFilter_ovr_0(target, format, &type, bufSize, image);
// added in gl4.5
private z_GetnHistogram_adr := GetFuncAdr('glGetnHistogram');
private z_GetnHistogram_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr)>(z_GetnHistogram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnHistogram(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr) :=
z_GetnHistogram_ovr_0(target, reset, format, &type, bufSize, values);
// added in gl4.5
private z_GetnMapdv_adr := GetFuncAdr('glGetnMapdv');
private z_GetnMapdv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real)>(z_GetnMapdv_adr);
private z_GetnMapdv_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapdv_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapdv_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real) :=
z_GetnMapdv_ovr_0(target, query, bufSize, v);
private z_GetnMapdv_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdv(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapdv_ovr_2(target, query, bufSize, v);
// added in gl4.5
private z_GetnMapfv_adr := GetFuncAdr('glGetnMapfv');
private z_GetnMapfv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single)>(z_GetnMapfv_adr);
private z_GetnMapfv_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapfv_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapfv_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single) :=
z_GetnMapfv_ovr_0(target, query, bufSize, v);
private z_GetnMapfv_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfv(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapfv_ovr_2(target, query, bufSize, v);
// added in gl4.5
private z_GetnMapiv_adr := GetFuncAdr('glGetnMapiv');
private z_GetnMapiv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32)>(z_GetnMapiv_adr);
private z_GetnMapiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapiv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapiv_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapiv_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapiv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32) :=
z_GetnMapiv_ovr_0(target, query, bufSize, v);
private z_GetnMapiv_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapiv(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapiv_ovr_2(target, query, bufSize, v);
// added in gl4.5
private z_GetnMinmax_adr := GetFuncAdr('glGetnMinmax');
private z_GetnMinmax_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr)>(z_GetnMinmax_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMinmax(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr) :=
z_GetnMinmax_ovr_0(target, reset, format, &type, bufSize, values);
// added in gl4.5
private z_GetnPixelMapfv_adr := GetFuncAdr('glGetnPixelMapfv');
private z_GetnPixelMapfv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: single)>(z_GetnPixelMapfv_adr);
private z_GetnPixelMapfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfv(map: PixelMap; bufSize: Int32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapfv_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapfv_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfv(map: PixelMap; bufSize: Int32; var values: single) :=
z_GetnPixelMapfv_ovr_0(map, bufSize, values);
private z_GetnPixelMapfv_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfv(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapfv_ovr_2(map, bufSize, values);
// added in gl4.5
private z_GetnPixelMapuiv_adr := GetFuncAdr('glGetnPixelMapuiv');
private z_GetnPixelMapuiv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt32)>(z_GetnPixelMapuiv_adr);
private z_GetnPixelMapuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuiv(map: PixelMap; bufSize: Int32; values: array of UInt32) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapuiv_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapuiv_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuiv(map: PixelMap; bufSize: Int32; var values: UInt32) :=
z_GetnPixelMapuiv_ovr_0(map, bufSize, values);
private z_GetnPixelMapuiv_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuiv(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapuiv_ovr_2(map, bufSize, values);
// added in gl4.5
private z_GetnPixelMapusv_adr := GetFuncAdr('glGetnPixelMapusv');
private z_GetnPixelMapusv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt16)>(z_GetnPixelMapusv_adr);
private z_GetnPixelMapusv_ovr_0_anh0001 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusv(map: PixelMap; bufSize: Int32; values: array of UInt16) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapusv_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapusv_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusv(map: PixelMap; bufSize: Int32; var values: UInt16) :=
z_GetnPixelMapusv_ovr_0(map, bufSize, values);
private z_GetnPixelMapusv_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusv(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapusv_ovr_2(map, bufSize, values);
// added in gl4.5
private z_GetnPolygonStipple_adr := GetFuncAdr('glGetnPolygonStipple');
private z_GetnPolygonStipple_ovr_0 := GetFuncOrNil&<procedure(bufSize: Int32; var pattern: Byte)>(z_GetnPolygonStipple_adr);
private z_GetnPolygonStipple_ovr_0_anh001 := GetFuncOrNil&<procedure(bufSize: Int32; pattern: IntPtr)>(z_GetnPolygonStipple_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; pattern: array of Byte) :=
if (pattern<>nil) and (pattern.Length<>0) then
z_GetnPolygonStipple_ovr_0(bufSize, pattern[0]) else
z_GetnPolygonStipple_ovr_0_anh001(bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; var pattern: Byte) :=
z_GetnPolygonStipple_ovr_0(bufSize, pattern);
private z_GetnPolygonStipple_ovr_2 := GetFuncOrNil&<procedure(bufSize: Int32; pattern: IntPtr)>(z_GetnPolygonStipple_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; pattern: IntPtr) :=
z_GetnPolygonStipple_ovr_2(bufSize, pattern);
// added in gl4.5
private z_GetnSeparableFilter_adr := GetFuncAdr('glGetnSeparableFilter');
private z_GetnSeparableFilter_ovr_0 := GetFuncOrNil&<procedure(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr)>(z_GetnSeparableFilter_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnSeparableFilter(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr) :=
z_GetnSeparableFilter_ovr_0(target, format, &type, rowBufSize, row, columnBufSize, column, span);
// added in gl4.5
private z_GetnTexImage_adr := GetFuncAdr('glGetnTexImage');
private z_GetnTexImage_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr)>(z_GetnTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnTexImage(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr) :=
z_GetnTexImage_ovr_0(target, level, format, &type, bufSize, pixels);
// added in gl4.5
private z_GetnUniformdv_adr := GetFuncAdr('glGetnUniformdv');
private z_GetnUniformdv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: real)>(z_GetnUniformdv_adr);
private z_GetnUniformdv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformdv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformdv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: real) :=
z_GetnUniformdv_ovr_0(&program, location, bufSize, ¶ms);
private z_GetnUniformdv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformdv_ovr_2(&program, location, bufSize, ¶ms);
// added in gl4.5
private z_GetnUniformfv_adr := GetFuncAdr('glGetnUniformfv');
private z_GetnUniformfv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single)>(z_GetnUniformfv_adr);
private z_GetnUniformfv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformfv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single) :=
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms);
private z_GetnUniformfv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformfv_ovr_2(&program, location, bufSize, ¶ms);
// added in gl4.5
private z_GetnUniformiv_adr := GetFuncAdr('glGetnUniformiv');
private z_GetnUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32)>(z_GetnUniformiv_adr);
private z_GetnUniformiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformiv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32) :=
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms);
private z_GetnUniformiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformiv_ovr_2(&program, location, bufSize, ¶ms);
// added in gl4.5
private z_GetnUniformuiv_adr := GetFuncAdr('glGetnUniformuiv');
private z_GetnUniformuiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32)>(z_GetnUniformuiv_adr);
private z_GetnUniformuiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformuiv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32) :=
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms);
private z_GetnUniformuiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformuiv_ovr_2(&program, location, bufSize, ¶ms);
// added in gl4.3
private z_GetObjectLabel_adr := GetFuncAdr('glGetObjectLabel');
private z_GetObjectLabel_ovr_0 := GetFuncOrNil&<procedure(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr)>(z_GetObjectLabel_adr);
private z_GetObjectLabel_ovr_0_anh000010 := GetFuncOrNil&<procedure(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr)>(z_GetObjectLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: array of Int32; &label: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length[0], &label) else
z_GetObjectLabel_ovr_0_anh000010(identifier, name, bufSize, IntPtr.Zero, &label);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr) :=
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length, &label);
private z_GetObjectLabel_ovr_2 := GetFuncOrNil&<procedure(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr)>(z_GetObjectLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr) :=
z_GetObjectLabel_ovr_2(identifier, name, bufSize, length, &label);
// added in gl4.3
private z_GetObjectPtrLabel_adr := GetFuncAdr('glGetObjectPtrLabel');
private z_GetObjectPtrLabel_ovr_0 := GetFuncOrNil&<procedure(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr)>(z_GetObjectPtrLabel_adr);
private z_GetObjectPtrLabel_ovr_0_anh00010 := GetFuncOrNil&<procedure(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr)>(z_GetObjectPtrLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; length: array of Int32; &label: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length[0], &label) else
z_GetObjectPtrLabel_ovr_0_anh00010(ptr, bufSize, IntPtr.Zero, &label);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr) :=
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length, &label);
private z_GetObjectPtrLabel_ovr_2 := GetFuncOrNil&<procedure(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr)>(z_GetObjectPtrLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr) :=
z_GetObjectPtrLabel_ovr_2(ptr, bufSize, length, &label);
// added in gl4.3
private z_GetPointerv_adr := GetFuncAdr('glGetPointerv');
private z_GetPointerv_ovr_0 := GetFuncOrNil&<procedure(pname: GetPointervPName; var ¶ms: IntPtr)>(z_GetPointerv_adr);
private z_GetPointerv_ovr_0_anh001 := GetFuncOrNil&<procedure(pname: GetPointervPName; ¶ms: IntPtr)>(z_GetPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPointerv_ovr_0(pname, ¶ms[0]) else
z_GetPointerv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; var ¶ms: IntPtr) :=
z_GetPointerv_ovr_0(pname, ¶ms);
private z_GetPointerv_ovr_2 := GetFuncOrNil&<procedure(pname: GetPointervPName; ¶ms: pointer)>(z_GetPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: pointer) :=
z_GetPointerv_ovr_2(pname, ¶ms);
// added in gl4.1
private z_GetProgramBinary_adr := GetFuncAdr('glGetProgramBinary');
private z_GetProgramBinary_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; binary: IntPtr)>(z_GetProgramBinary_adr);
private z_GetProgramBinary_ovr_0_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr)>(z_GetProgramBinary_adr);
private z_GetProgramBinary_ovr_0_anh000010 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
private z_GetProgramBinary_ovr_0_anh000110 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000010(&program, bufSize, length[0], IntPtr.Zero, binary) else
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000110(&program, bufSize, IntPtr.Zero, IntPtr.Zero, binary);
private z_GetProgramBinary_ovr_1_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr)>(z_GetProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; var binaryFormat: DummyEnum; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat, binary) else
z_GetProgramBinary_ovr_0_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat, binary);
private z_GetProgramBinary_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
private z_GetProgramBinary_ovr_2_anh000100 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; binaryFormat: IntPtr; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramBinary_ovr_2(&program, bufSize, length[0], binaryFormat, binary) else
z_GetProgramBinary_ovr_2_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000010(&program, bufSize, length, IntPtr.Zero, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; binary: IntPtr) :=
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr) :=
z_GetProgramBinary_ovr_2(&program, bufSize, length, binaryFormat, binary);
private z_GetProgramBinary_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr)>(z_GetProgramBinary_adr);
private z_GetProgramBinary_ovr_6_anh000010 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_6_anh000010(&program, bufSize, length, IntPtr.Zero, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr) :=
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat, binary);
private z_GetProgramBinary_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr)>(z_GetProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr) :=
z_GetProgramBinary_ovr_8(&program, bufSize, length, binaryFormat, binary);
// added in gl2.0
private z_GetProgramInfoLog_adr := GetFuncAdr('glGetProgramInfoLog');
private z_GetProgramInfoLog_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; bufSize: Int32; var length: Int32; infoLog: IntPtr)>(z_GetProgramInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInfoLog(&program: ProgramName; bufSize: Int32; var length: Int32; infoLog: IntPtr) :=
z_GetProgramInfoLog_ovr_0(&program, bufSize, length, infoLog);
private z_GetProgramInfoLog_ovr_1 := GetFuncOrNil&<procedure(&program: ProgramName; bufSize: Int32; length: IntPtr; infoLog: IntPtr)>(z_GetProgramInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInfoLog(&program: ProgramName; bufSize: Int32; length: IntPtr; infoLog: IntPtr) :=
z_GetProgramInfoLog_ovr_1(&program, bufSize, length, infoLog);
// added in gl4.3
private z_GetProgramInterfaceiv_adr := GetFuncAdr('glGetProgramInterfaceiv');
private z_GetProgramInterfaceiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32)>(z_GetProgramInterfaceiv_adr);
private z_GetProgramInterfaceiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr)>(z_GetProgramInterfaceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms[0]) else
z_GetProgramInterfaceiv_ovr_0_anh00001(&program, _programInterface, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32) :=
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms);
private z_GetProgramInterfaceiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr)>(z_GetProgramInterfaceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr) :=
z_GetProgramInterfaceiv_ovr_2(&program, _programInterface, pname, ¶ms);
// added in gl2.0
private z_GetProgramiv_adr := GetFuncAdr('glGetProgramiv');
private z_GetProgramiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; pname: ProgramPropertyARB; var ¶ms: Int32)>(z_GetProgramiv_adr);
private z_GetProgramiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(&program: ProgramName; pname: ProgramPropertyARB; ¶ms: IntPtr)>(z_GetProgramiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramiv(&program: ProgramName; pname: ProgramPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramiv_ovr_0(&program, pname, ¶ms[0]) else
z_GetProgramiv_ovr_0_anh0001(&program, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramiv(&program: ProgramName; pname: ProgramPropertyARB; var ¶ms: Int32) :=
z_GetProgramiv_ovr_0(&program, pname, ¶ms);
private z_GetProgramiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; pname: ProgramPropertyARB; ¶ms: IntPtr)>(z_GetProgramiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramiv(&program: ProgramName; pname: ProgramPropertyARB; ¶ms: IntPtr) :=
z_GetProgramiv_ovr_2(&program, pname, ¶ms);
// added in gl4.1
private z_GetProgramPipelineInfoLog_adr := GetFuncAdr('glGetProgramPipelineInfoLog');
private z_GetProgramPipelineInfoLog_ovr_0 := GetFuncOrNil&<procedure(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr)>(z_GetProgramPipelineInfoLog_adr);
private z_GetProgramPipelineInfoLog_ovr_0_anh00010 := GetFuncOrNil&<procedure(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr)>(z_GetProgramPipelineInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; length: array of Int32; infoLog: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length[0], infoLog) else
z_GetProgramPipelineInfoLog_ovr_0_anh00010(pipeline, bufSize, IntPtr.Zero, infoLog);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr) :=
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length, infoLog);
private z_GetProgramPipelineInfoLog_ovr_2 := GetFuncOrNil&<procedure(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr)>(z_GetProgramPipelineInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr) :=
z_GetProgramPipelineInfoLog_ovr_2(pipeline, bufSize, length, infoLog);
// added in gl4.1
private z_GetProgramPipelineiv_adr := GetFuncAdr('glGetProgramPipelineiv');
private z_GetProgramPipelineiv_ovr_0 := GetFuncOrNil&<procedure(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32)>(z_GetProgramPipelineiv_adr);
private z_GetProgramPipelineiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr)>(z_GetProgramPipelineiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms[0]) else
z_GetProgramPipelineiv_ovr_0_anh0001(pipeline, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32) :=
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms);
private z_GetProgramPipelineiv_ovr_2 := GetFuncOrNil&<procedure(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr)>(z_GetProgramPipelineiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr) :=
z_GetProgramPipelineiv_ovr_2(pipeline, pname, ¶ms);
// added in gl4.3
private z_GetProgramResourceIndex_adr := GetFuncAdr('glGetProgramResourceIndex');
private z_GetProgramResourceIndex_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): UInt32>(z_GetProgramResourceIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceIndex(&program: ProgramName; _programInterface: ProgramInterface; name: string): UInt32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceIndex_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceIndex(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): UInt32 :=
z_GetProgramResourceIndex_ovr_0(&program, _programInterface, name);
// added in gl4.3
private z_GetProgramResourceiv_adr := GetFuncAdr('glGetProgramResourceiv');
private z_GetProgramResourceiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000001010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000000001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000001001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000000011 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_0_anh000001011 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000011(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001011(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, IntPtr.Zero);
private z_GetProgramResourceiv_ovr_1_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_1_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_1_anh000001010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private z_GetProgramResourceiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_2_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_2_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_2_anh000001010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private z_GetProgramResourceiv_ovr_3_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_3_anh000001001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private z_GetProgramResourceiv_ovr_4_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_5_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_6_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_6_anh000000001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_6_anh000001001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private z_GetProgramResourceiv_ovr_7_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_8_anh000001000 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_8_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_18_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_18_anh000000001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_18_anh000000011 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
private z_GetProgramResourceiv_ovr_19_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
private z_GetProgramResourceiv_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_20_anh000000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_20_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32)>(z_GetProgramResourceiv_adr);
private z_GetProgramResourceiv_ovr_24_anh000000001 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_24_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private z_GetProgramResourceiv_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_26(&program, _programInterface, index, propCount, props, count, length, ¶ms);
// added in gl4.3
private z_GetProgramResourceLocation_adr := GetFuncAdr('glGetProgramResourceLocation');
private z_GetProgramResourceLocation_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32>(z_GetProgramResourceLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocation(&program: ProgramName; _programInterface: ProgramInterface; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceLocation_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocation(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32 :=
z_GetProgramResourceLocation_ovr_0(&program, _programInterface, name);
// added in gl4.3
private z_GetProgramResourceLocationIndex_adr := GetFuncAdr('glGetProgramResourceLocationIndex');
private z_GetProgramResourceLocationIndex_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32>(z_GetProgramResourceLocationIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocationIndex(&program: ProgramName; _programInterface: ProgramInterface; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceLocationIndex_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocationIndex(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32 :=
z_GetProgramResourceLocationIndex_ovr_0(&program, _programInterface, name);
// added in gl4.3
private z_GetProgramResourceName_adr := GetFuncAdr('glGetProgramResourceName');
private z_GetProgramResourceName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr)>(z_GetProgramResourceName_adr);
private z_GetProgramResourceName_ovr_0_anh0000010 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetProgramResourceName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length[0], name) else
z_GetProgramResourceName_ovr_0_anh0000010(&program, _programInterface, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length, name);
private z_GetProgramResourceName_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr)>(z_GetProgramResourceName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetProgramResourceName_ovr_2(&program, _programInterface, index, bufSize, length, name);
// added in gl4.0
private z_GetProgramStageiv_adr := GetFuncAdr('glGetProgramStageiv');
private z_GetProgramStageiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32)>(z_GetProgramStageiv_adr);
private z_GetProgramStageiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr)>(z_GetProgramStageiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values[0]) else
z_GetProgramStageiv_ovr_0_anh00001(&program, _shadertype, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32) :=
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values);
private z_GetProgramStageiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr)>(z_GetProgramStageiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr) :=
z_GetProgramStageiv_ovr_2(&program, _shadertype, pname, values);
// added in gl4.5
private z_GetQueryBufferObjecti64v_adr := GetFuncAdr('glGetQueryBufferObjecti64v');
private z_GetQueryBufferObjecti64v_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr)>(z_GetQueryBufferObjecti64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjecti64v(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjecti64v_ovr_0(id, buffer, pname, offset);
// added in gl4.5
private z_GetQueryBufferObjectiv_adr := GetFuncAdr('glGetQueryBufferObjectiv');
private z_GetQueryBufferObjectiv_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr)>(z_GetQueryBufferObjectiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectiv(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectiv_ovr_0(id, buffer, pname, offset);
// added in gl4.5
private z_GetQueryBufferObjectui64v_adr := GetFuncAdr('glGetQueryBufferObjectui64v');
private z_GetQueryBufferObjectui64v_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr)>(z_GetQueryBufferObjectui64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectui64v(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectui64v_ovr_0(id, buffer, pname, offset);
// added in gl4.5
private z_GetQueryBufferObjectuiv_adr := GetFuncAdr('glGetQueryBufferObjectuiv');
private z_GetQueryBufferObjectuiv_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr)>(z_GetQueryBufferObjectuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectuiv(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectuiv_ovr_0(id, buffer, pname, offset);
// added in gl4.0
private z_GetQueryIndexediv_adr := GetFuncAdr('glGetQueryIndexediv');
private z_GetQueryIndexediv_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32)>(z_GetQueryIndexediv_adr);
private z_GetQueryIndexediv_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr)>(z_GetQueryIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms[0]) else
z_GetQueryIndexediv_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32) :=
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms);
private z_GetQueryIndexediv_ovr_2 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr)>(z_GetQueryIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr) :=
z_GetQueryIndexediv_ovr_2(target, index, pname, ¶ms);
// added in gl1.5
private z_GetQueryiv_adr := GetFuncAdr('glGetQueryiv');
private z_GetQueryiv_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32)>(z_GetQueryiv_adr);
private z_GetQueryiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr)>(z_GetQueryiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryiv(target: QueryTarget; pname: QueryParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryiv_ovr_0(target, pname, ¶ms[0]) else
z_GetQueryiv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryiv(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32) :=
z_GetQueryiv_ovr_0(target, pname, ¶ms);
private z_GetQueryiv_ovr_2 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr)>(z_GetQueryiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryiv(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr) :=
z_GetQueryiv_ovr_2(target, pname, ¶ms);
// added in gl3.3
private z_GetQueryObjecti64v_adr := GetFuncAdr('glGetQueryObjecti64v');
private z_GetQueryObjecti64v_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64)>(z_GetQueryObjecti64v_adr);
private z_GetQueryObjecti64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjecti64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjecti64v_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64) :=
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms);
private z_GetQueryObjecti64v_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjecti64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjecti64v_ovr_2(id, pname, ¶ms);
// added in gl1.5
private z_GetQueryObjectiv_adr := GetFuncAdr('glGetQueryObjectiv');
private z_GetQueryObjectiv_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32)>(z_GetQueryObjectiv_adr);
private z_GetQueryObjectiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectiv_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectiv_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectiv(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32) :=
z_GetQueryObjectiv_ovr_0(id, pname, ¶ms);
private z_GetQueryObjectiv_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectiv_ovr_2(id, pname, ¶ms);
// added in gl3.3
private z_GetQueryObjectui64v_adr := GetFuncAdr('glGetQueryObjectui64v');
private z_GetQueryObjectui64v_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64)>(z_GetQueryObjectui64v_adr);
private z_GetQueryObjectui64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectui64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectui64v_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64) :=
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms);
private z_GetQueryObjectui64v_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectui64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectui64v_ovr_2(id, pname, ¶ms);
// added in gl1.5
private z_GetQueryObjectuiv_adr := GetFuncAdr('glGetQueryObjectuiv');
private z_GetQueryObjectuiv_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32)>(z_GetQueryObjectuiv_adr);
private z_GetQueryObjectuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectuiv_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectuiv_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuiv(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32) :=
z_GetQueryObjectuiv_ovr_0(id, pname, ¶ms);
private z_GetQueryObjectuiv_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectuiv_ovr_2(id, pname, ¶ms);
// added in gl3.0
private z_GetRenderbufferParameteriv_adr := GetFuncAdr('glGetRenderbufferParameteriv');
private z_GetRenderbufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetRenderbufferParameteriv_adr);
private z_GetRenderbufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetRenderbufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms);
private z_GetRenderbufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetRenderbufferParameteriv_ovr_2(target, pname, ¶ms);
// added in gl3.3
private z_GetSamplerParameterfv_adr := GetFuncAdr('glGetSamplerParameterfv');
private z_GetSamplerParameterfv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterF; var ¶ms: single)>(z_GetSamplerParameterfv_adr);
private z_GetSamplerParameterfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterF; ¶ms: IntPtr)>(z_GetSamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: SamplerParameterF; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterfv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: SamplerParameterF; var ¶ms: single) :=
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms);
private z_GetSamplerParameterfv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterF; ¶ms: IntPtr)>(z_GetSamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: SamplerParameterF; ¶ms: IntPtr) :=
z_GetSamplerParameterfv_ovr_2(sampler, pname, ¶ms);
// added in gl3.3
private z_GetSamplerParameterIiv_adr := GetFuncAdr('glGetSamplerParameterIiv');
private z_GetSamplerParameterIiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32)>(z_GetSamplerParameterIiv_adr);
private z_GetSamplerParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterIiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32) :=
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms);
private z_GetSamplerParameterIiv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameterIiv_ovr_2(sampler, pname, ¶ms);
// added in gl3.3
private z_GetSamplerParameterIuiv_adr := GetFuncAdr('glGetSamplerParameterIuiv');
private z_GetSamplerParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: UInt32)>(z_GetSamplerParameterIuiv_adr);
private z_GetSamplerParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterIuiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: UInt32) :=
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms);
private z_GetSamplerParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameterIuiv_ovr_2(sampler, pname, ¶ms);
// added in gl3.3
private z_GetSamplerParameteriv_adr := GetFuncAdr('glGetSamplerParameteriv');
private z_GetSamplerParameteriv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32)>(z_GetSamplerParameteriv_adr);
private z_GetSamplerParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameteriv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32) :=
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms);
private z_GetSamplerParameteriv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr)>(z_GetSamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameteriv_ovr_2(sampler, pname, ¶ms);
// added in gl2.0
private z_GetShaderInfoLog_adr := GetFuncAdr('glGetShaderInfoLog');
private z_GetShaderInfoLog_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName; bufSize: Int32; var length: Int32; infoLog: IntPtr)>(z_GetShaderInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderInfoLog(shader: ShaderName; bufSize: Int32; var length: Int32; infoLog: IntPtr) :=
z_GetShaderInfoLog_ovr_0(shader, bufSize, length, infoLog);
private z_GetShaderInfoLog_ovr_1 := GetFuncOrNil&<procedure(shader: ShaderName; bufSize: Int32; length: IntPtr; infoLog: IntPtr)>(z_GetShaderInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderInfoLog(shader: ShaderName; bufSize: Int32; length: IntPtr; infoLog: IntPtr) :=
z_GetShaderInfoLog_ovr_1(shader, bufSize, length, infoLog);
// added in gl2.0
private z_GetShaderiv_adr := GetFuncAdr('glGetShaderiv');
private z_GetShaderiv_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName; pname: ShaderParameterName; var ¶ms: Int32)>(z_GetShaderiv_adr);
private z_GetShaderiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(shader: ShaderName; pname: ShaderParameterName; ¶ms: IntPtr)>(z_GetShaderiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderiv(shader: ShaderName; pname: ShaderParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetShaderiv_ovr_0(shader, pname, ¶ms[0]) else
z_GetShaderiv_ovr_0_anh0001(shader, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderiv(shader: ShaderName; pname: ShaderParameterName; var ¶ms: Int32) :=
z_GetShaderiv_ovr_0(shader, pname, ¶ms);
private z_GetShaderiv_ovr_2 := GetFuncOrNil&<procedure(shader: ShaderName; pname: ShaderParameterName; ¶ms: IntPtr)>(z_GetShaderiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderiv(shader: ShaderName; pname: ShaderParameterName; ¶ms: IntPtr) :=
z_GetShaderiv_ovr_2(shader, pname, ¶ms);
// added in gl4.1
private z_GetShaderPrecisionFormat_adr := GetFuncAdr('glGetShaderPrecisionFormat');
private z_GetShaderPrecisionFormat_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32)>(z_GetShaderPrecisionFormat_adr);
private z_GetShaderPrecisionFormat_ovr_0_anh00010 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32)>(z_GetShaderPrecisionFormat_adr);
private z_GetShaderPrecisionFormat_ovr_0_anh00001 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
private z_GetShaderPrecisionFormat_ovr_0_anh00011 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: array of Int32) :=
if (range<>nil) and (range.Length<>0) then
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00001(_shadertype, _precisiontype, range[0], IntPtr.Zero) else
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00011(_shadertype, _precisiontype, IntPtr.Zero, IntPtr.Zero);
private z_GetShaderPrecisionFormat_ovr_1_anh00010 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; var precision: Int32) :=
if (range<>nil) and (range.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision) else
z_GetShaderPrecisionFormat_ovr_0_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision);
private z_GetShaderPrecisionFormat_ovr_2 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
private z_GetShaderPrecisionFormat_ovr_2_anh00010 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: IntPtr) :=
if (range<>nil) and (range.Length<>0) then
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range[0], precision) else
z_GetShaderPrecisionFormat_ovr_2_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: array of Int32) :=
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00001(_shadertype, _precisiontype, range, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32) :=
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr) :=
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range, precision);
private z_GetShaderPrecisionFormat_ovr_6 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32)>(z_GetShaderPrecisionFormat_adr);
private z_GetShaderPrecisionFormat_ovr_6_anh00001 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: array of Int32) :=
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision[0]) else
z_GetShaderPrecisionFormat_ovr_6_anh00001(_shadertype, _precisiontype, range, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32) :=
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision);
private z_GetShaderPrecisionFormat_ovr_8 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr) :=
z_GetShaderPrecisionFormat_ovr_8(_shadertype, _precisiontype, range, precision);
// added in gl2.0
private z_GetShaderSource_adr := GetFuncAdr('glGetShaderSource');
private z_GetShaderSource_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; bufSize: Int32; var length: Int32; source: IntPtr)>(z_GetShaderSource_adr);
private z_GetShaderSource_ovr_0_anh00010 := GetFuncOrNil&<procedure(shader: UInt32; bufSize: Int32; length: IntPtr; source: IntPtr)>(z_GetShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSource(shader: UInt32; bufSize: Int32; length: array of Int32; source: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetShaderSource_ovr_0(shader, bufSize, length[0], source) else
z_GetShaderSource_ovr_0_anh00010(shader, bufSize, IntPtr.Zero, source);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSource(shader: UInt32; bufSize: Int32; var length: Int32; source: IntPtr) :=
z_GetShaderSource_ovr_0(shader, bufSize, length, source);
private z_GetShaderSource_ovr_2 := GetFuncOrNil&<procedure(shader: UInt32; bufSize: Int32; length: IntPtr; source: IntPtr)>(z_GetShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSource(shader: UInt32; bufSize: Int32; length: IntPtr; source: IntPtr) :=
z_GetShaderSource_ovr_2(shader, bufSize, length, source);
// added in gl1.0
private static function z_GetString_ovr_0(name: StringName): IntPtr;
external 'opengl32.dll' name 'glGetString';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetString(name: StringName): string;
begin
var res_str_ptr := z_GetString_ovr_0(name);
Result := Marshal.PtrToStringAnsi(res_str_ptr);
end;
// added in gl3.0
private z_GetStringi_adr := GetFuncAdr('glGetStringi');
private z_GetStringi_ovr_0 := GetFuncOrNil&<function(name: StringName; index: UInt32): IntPtr>(z_GetStringi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetStringi(name: StringName; index: UInt32): string;
begin
var res_str_ptr := z_GetStringi_ovr_0(name, index);
Result := Marshal.PtrToStringAnsi(res_str_ptr);
end;
// added in gl4.0
private z_GetSubroutineIndex_adr := GetFuncAdr('glGetSubroutineIndex');
private z_GetSubroutineIndex_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): UInt32>(z_GetSubroutineIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineIndex(&program: ProgramName; _shadertype: ShaderType; name: string): UInt32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetSubroutineIndex_ovr_0(&program, _shadertype, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineIndex(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): UInt32 :=
z_GetSubroutineIndex_ovr_0(&program, _shadertype, name);
// added in gl4.0
private z_GetSubroutineUniformLocation_adr := GetFuncAdr('glGetSubroutineUniformLocation');
private z_GetSubroutineUniformLocation_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): Int32>(z_GetSubroutineUniformLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineUniformLocation(&program: ProgramName; _shadertype: ShaderType; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetSubroutineUniformLocation_ovr_0(&program, _shadertype, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineUniformLocation(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): Int32 :=
z_GetSubroutineUniformLocation_ovr_0(&program, _shadertype, name);
// added in gl3.2
private z_GetSynciv_adr := GetFuncAdr('glGetSynciv');
private z_GetSynciv_ovr_0 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32)>(z_GetSynciv_adr);
private z_GetSynciv_ovr_0_anh000010 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32)>(z_GetSynciv_adr);
private z_GetSynciv_ovr_0_anh000001 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr)>(z_GetSynciv_adr);
private z_GetSynciv_ovr_0_anh000011 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length[0], values[0]) else
z_GetSynciv_ovr_0_anh000001(sync, pname, count, length[0], IntPtr.Zero) else
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0_anh000010(sync, pname, count, IntPtr.Zero, values[0]) else
z_GetSynciv_ovr_0_anh000011(sync, pname, count, IntPtr.Zero, IntPtr.Zero);
private z_GetSynciv_ovr_1_anh000010 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; var values: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length[0], values) else
z_GetSynciv_ovr_0_anh000010(sync, pname, count, IntPtr.Zero, values);
private z_GetSynciv_ovr_2 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr)>(z_GetSynciv_adr);
private z_GetSynciv_ovr_2_anh000010 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetSynciv_ovr_2(sync, pname, count, length[0], values) else
z_GetSynciv_ovr_2_anh000010(sync, pname, count, IntPtr.Zero, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length, values[0]) else
z_GetSynciv_ovr_0_anh000001(sync, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32) :=
z_GetSynciv_ovr_0(sync, pname, count, length, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr) :=
z_GetSynciv_ovr_2(sync, pname, count, length, values);
private z_GetSynciv_ovr_6 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32)>(z_GetSynciv_adr);
private z_GetSynciv_ovr_6_anh000001 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_6(sync, pname, count, length, values[0]) else
z_GetSynciv_ovr_6_anh000001(sync, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32) :=
z_GetSynciv_ovr_6(sync, pname, count, length, values);
private z_GetSynciv_ovr_8 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr) :=
z_GetSynciv_ovr_8(sync, pname, count, length, values);
// added in gl1.0
private static procedure z_GetTexImage_ovr_0(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glGetTexImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexImage(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_GetTexImage_ovr_0(target, level, format, &type, pixels);
// added in gl1.0
private static procedure z_GetTexLevelParameterfv_ovr_0(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
private static procedure z_GetTexLevelParameterfv_ovr_0_anh00001(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexLevelParameterfv_ovr_0(target, level, pname, ¶ms[0]) else
z_GetTexLevelParameterfv_ovr_0_anh00001(target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTexLevelParameterfv_ovr_0(target, level, pname, ¶ms);
private static procedure z_GetTexLevelParameterfv_ovr_2(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexLevelParameterfv_ovr_2(target, level, pname, ¶ms);
// added in gl1.0
private static procedure z_GetTexLevelParameteriv_ovr_0(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
private static procedure z_GetTexLevelParameteriv_ovr_0_anh00001(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexLevelParameteriv_ovr_0(target, level, pname, ¶ms[0]) else
z_GetTexLevelParameteriv_ovr_0_anh00001(target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTexLevelParameteriv_ovr_0(target, level, pname, ¶ms);
private static procedure z_GetTexLevelParameteriv_ovr_2(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexLevelParameteriv_ovr_2(target, level, pname, ¶ms);
// added in gl1.0
private static procedure z_GetTexParameterfv_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexParameterfv';
private static procedure z_GetTexParameterfv_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTexParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameterfv_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterfv_ovr_2(target, pname, ¶ms);
// added in gl3.0
private z_GetTexParameterIiv_adr := GetFuncAdr('glGetTexParameterIiv');
private z_GetTexParameterIiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTexParameterIiv_adr);
private z_GetTexParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterIiv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterIiv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIiv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTexParameterIiv_ovr_0(target, pname, ¶ms);
private z_GetTexParameterIiv_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterIiv_ovr_2(target, pname, ¶ms);
// added in gl3.0
private z_GetTexParameterIuiv_adr := GetFuncAdr('glGetTexParameterIuiv');
private z_GetTexParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTexParameterIuiv_adr);
private z_GetTexParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterIuiv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterIuiv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuiv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetTexParameterIuiv_ovr_0(target, pname, ¶ms);
private z_GetTexParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterIuiv_ovr_2(target, pname, ¶ms);
// added in gl1.0
private static procedure z_GetTexParameteriv_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexParameteriv';
private static procedure z_GetTexParameteriv_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTexParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameteriv_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameteriv_ovr_2(target, pname, ¶ms);
// added in gl4.5
private z_GetTextureImage_adr := GetFuncAdr('glGetTextureImage');
private z_GetTextureImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr)>(z_GetTextureImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureImage(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr) :=
z_GetTextureImage_ovr_0(texture, level, format, &type, bufSize, pixels);
// added in gl4.5
private z_GetTextureLevelParameterfv_adr := GetFuncAdr('glGetTextureLevelParameterfv');
private z_GetTextureLevelParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureLevelParameterfv_adr);
private z_GetTextureLevelParameterfv_ovr_0_anh00001 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms[0]) else
z_GetTextureLevelParameterfv_ovr_0_anh00001(texture, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms);
private z_GetTextureLevelParameterfv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameterfv_ovr_2(texture, level, pname, ¶ms);
// added in gl4.5
private z_GetTextureLevelParameteriv_adr := GetFuncAdr('glGetTextureLevelParameteriv');
private z_GetTextureLevelParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureLevelParameteriv_adr);
private z_GetTextureLevelParameteriv_ovr_0_anh00001 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms[0]) else
z_GetTextureLevelParameteriv_ovr_0_anh00001(texture, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms);
private z_GetTextureLevelParameteriv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameteriv_ovr_2(texture, level, pname, ¶ms);
// added in gl4.5
private z_GetTextureParameterfv_adr := GetFuncAdr('glGetTextureParameterfv');
private z_GetTextureParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureParameterfv_adr);
private z_GetTextureParameterfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterfv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms);
private z_GetTextureParameterfv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterfv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_GetTextureParameterIiv_adr := GetFuncAdr('glGetTextureParameterIiv');
private z_GetTextureParameterIiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameterIiv_adr);
private z_GetTextureParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterIiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms);
private z_GetTextureParameterIiv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIiv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_GetTextureParameterIuiv_adr := GetFuncAdr('glGetTextureParameterIuiv');
private z_GetTextureParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTextureParameterIuiv_adr);
private z_GetTextureParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterIuiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms);
private z_GetTextureParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIuiv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_GetTextureParameteriv_adr := GetFuncAdr('glGetTextureParameteriv');
private z_GetTextureParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameteriv_adr);
private z_GetTextureParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameteriv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms);
private z_GetTextureParameteriv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameteriv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_GetTextureSubImage_adr := GetFuncAdr('glGetTextureSubImage');
private z_GetTextureSubImage_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr)>(z_GetTextureSubImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr) :=
z_GetTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, bufSize, pixels);
// added in gl4.5
private z_GetTransformFeedbacki_v_adr := GetFuncAdr('glGetTransformFeedbacki_v');
private z_GetTransformFeedbacki_v_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32)>(z_GetTransformFeedbacki_v_adr);
private z_GetTransformFeedbacki_v_ovr_0_anh00001 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr)>(z_GetTransformFeedbacki_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param[0]) else
z_GetTransformFeedbacki_v_ovr_0_anh00001(xfb, pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32) :=
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param);
private z_GetTransformFeedbacki_v_ovr_2 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr)>(z_GetTransformFeedbacki_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr) :=
z_GetTransformFeedbacki_v_ovr_2(xfb, pname, index, param);
// added in gl4.5
private z_GetTransformFeedbacki64_v_adr := GetFuncAdr('glGetTransformFeedbacki64_v');
private z_GetTransformFeedbacki64_v_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64)>(z_GetTransformFeedbacki64_v_adr);
private z_GetTransformFeedbacki64_v_ovr_0_anh00001 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr)>(z_GetTransformFeedbacki64_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int64) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param[0]) else
z_GetTransformFeedbacki64_v_ovr_0_anh00001(xfb, pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64) :=
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param);
private z_GetTransformFeedbacki64_v_ovr_2 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr)>(z_GetTransformFeedbacki64_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr) :=
z_GetTransformFeedbacki64_v_ovr_2(xfb, pname, index, param);
// added in gl4.5
private z_GetTransformFeedbackiv_adr := GetFuncAdr('glGetTransformFeedbackiv');
private z_GetTransformFeedbackiv_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32)>(z_GetTransformFeedbackiv_adr);
private z_GetTransformFeedbackiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr)>(z_GetTransformFeedbackiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param[0]) else
z_GetTransformFeedbackiv_ovr_0_anh0001(xfb, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32) :=
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param);
private z_GetTransformFeedbackiv_ovr_2 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr)>(z_GetTransformFeedbackiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr) :=
z_GetTransformFeedbackiv_ovr_2(xfb, pname, param);
// added in gl3.0
private z_GetTransformFeedbackVarying_adr := GetFuncAdr('glGetTransformFeedbackVarying');
private z_GetTransformFeedbackVarying_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_0_anh00001110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000010(&program, index, bufSize, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000110(&program, index, bufSize, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00001110(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private z_GetTransformFeedbackVarying_ovr_1_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_1_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_1_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetTransformFeedbackVarying_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_2_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_2_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_2_anh00001100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_2_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_2_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private z_GetTransformFeedbackVarying_ovr_3_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_3_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetTransformFeedbackVarying_ovr_4_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVarying_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_5_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVarying_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_6_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_6_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_6_anh00001010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_6_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_6_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private z_GetTransformFeedbackVarying_ovr_7_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVarying_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_8_anh00001000 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVarying_ovr_8(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVarying_ovr_8_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_2_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_0_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_6_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_8(&program, index, bufSize, length, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_18_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_18_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_18_anh00000110 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetTransformFeedbackVarying_ovr_18_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_18_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
private z_GetTransformFeedbackVarying_ovr_19_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
private z_GetTransformFeedbackVarying_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_20_anh00000100 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVarying_ovr_20(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVarying_ovr_20_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_18_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_20(&program, index, bufSize, length, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
private z_GetTransformFeedbackVarying_ovr_24_anh00000010 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVarying_ovr_24(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVarying_ovr_24_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_24(&program, index, bufSize, length, size, &type, name);
private z_GetTransformFeedbackVarying_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVarying_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVarying_ovr_26(&program, index, bufSize, length, size, &type, name);
// added in gl3.1
private z_GetUniformBlockIndex_adr := GetFuncAdr('glGetUniformBlockIndex');
private z_GetUniformBlockIndex_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; uniformBlockName: IntPtr): UInt32>(z_GetUniformBlockIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBlockIndex(&program: ProgramName; uniformBlockName: string): UInt32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(uniformBlockName);
Result := z_GetUniformBlockIndex_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBlockIndex(&program: ProgramName; uniformBlockName: IntPtr): UInt32 :=
z_GetUniformBlockIndex_ovr_0(&program, uniformBlockName);
// added in gl4.0
private z_GetUniformdv_adr := GetFuncAdr('glGetUniformdv');
private z_GetUniformdv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: real)>(z_GetUniformdv_adr);
private z_GetUniformdv_ovr_0_anh0001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformdv_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformdv_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; var ¶ms: real) :=
z_GetUniformdv_ovr_0(&program, location, ¶ms);
private z_GetUniformdv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; ¶ms: IntPtr) :=
z_GetUniformdv_ovr_2(&program, location, ¶ms);
// added in gl2.0
private z_GetUniformfv_adr := GetFuncAdr('glGetUniformfv');
private z_GetUniformfv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: single)>(z_GetUniformfv_adr);
private z_GetUniformfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfv(&program: ProgramName; location: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformfv_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformfv_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfv(&program: ProgramName; location: Int32; var ¶ms: single) :=
z_GetUniformfv_ovr_0(&program, location, ¶ms);
private z_GetUniformfv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfv(&program: ProgramName; location: Int32; ¶ms: IntPtr) :=
z_GetUniformfv_ovr_2(&program, location, ¶ms);
// added in gl3.1
private z_GetUniformIndices_adr := GetFuncAdr('glGetUniformIndices');
private z_GetUniformIndices_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_0_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_0_anh00011 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; uniformIndices: array of UInt32);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00001(&program, uniformCount, par_3_str_ptr[0], IntPtr.Zero) else
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00011(&program, uniformCount, IntPtr.Zero, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_GetUniformIndices_ovr_1_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; var uniformIndices: UInt32);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices) else
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_GetUniformIndices_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_2_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; uniformIndices: IntPtr);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_GetUniformIndices_ovr_2(&program, uniformCount, par_3_str_ptr[0], uniformIndices) else
z_GetUniformIndices_ovr_2_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_GetUniformIndices_ovr_3_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_3_anh00011 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: array of UInt32) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00001(&program, uniformCount, uniformNames[0], IntPtr.Zero) else
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00011(&program, uniformCount, IntPtr.Zero, IntPtr.Zero);
private z_GetUniformIndices_ovr_4_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; var uniformIndices: UInt32) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices) else
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
private z_GetUniformIndices_ovr_5_anh00010 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: IntPtr) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
z_GetUniformIndices_ovr_2(&program, uniformCount, uniformNames[0], uniformIndices) else
z_GetUniformIndices_ovr_2_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
private z_GetUniformIndices_ovr_6 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32)>(z_GetUniformIndices_adr);
private z_GetUniformIndices_ovr_6_anh00001 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: array of UInt32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices[0]) else
z_GetUniformIndices_ovr_6_anh00001(&program, uniformCount, uniformNames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32) :=
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices);
private z_GetUniformIndices_ovr_8 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr)>(z_GetUniformIndices_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr) :=
z_GetUniformIndices_ovr_8(&program, uniformCount, uniformNames, uniformIndices);
// added in gl2.0
private z_GetUniformiv_adr := GetFuncAdr('glGetUniformiv');
private z_GetUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: Int32)>(z_GetUniformiv_adr);
private z_GetUniformiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformiv(&program: ProgramName; location: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformiv_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformiv_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformiv(&program: ProgramName; location: Int32; var ¶ms: Int32) :=
z_GetUniformiv_ovr_0(&program, location, ¶ms);
private z_GetUniformiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformiv(&program: ProgramName; location: Int32; ¶ms: IntPtr) :=
z_GetUniformiv_ovr_2(&program, location, ¶ms);
// added in gl2.0
private z_GetUniformLocation_adr := GetFuncAdr('glGetUniformLocation');
private z_GetUniformLocation_ovr_0 := GetFuncOrNil&<function(&program: ProgramName; name: IntPtr): Int32>(z_GetUniformLocation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformLocation(&program: ProgramName; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetUniformLocation_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformLocation(&program: ProgramName; name: IntPtr): Int32 :=
z_GetUniformLocation_ovr_0(&program, name);
// added in gl4.0
private z_GetUniformSubroutineuiv_adr := GetFuncAdr('glGetUniformSubroutineuiv');
private z_GetUniformSubroutineuiv_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32)>(z_GetUniformSubroutineuiv_adr);
private z_GetUniformSubroutineuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr)>(z_GetUniformSubroutineuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms[0]) else
z_GetUniformSubroutineuiv_ovr_0_anh0001(_shadertype, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32) :=
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms);
private z_GetUniformSubroutineuiv_ovr_2 := GetFuncOrNil&<procedure(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr)>(z_GetUniformSubroutineuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr) :=
z_GetUniformSubroutineuiv_ovr_2(_shadertype, location, ¶ms);
// added in gl3.0
private z_GetUniformuiv_adr := GetFuncAdr('glGetUniformuiv');
private z_GetUniformuiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: UInt32)>(z_GetUniformuiv_adr);
private z_GetUniformuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuiv(&program: ProgramName; location: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformuiv_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformuiv_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuiv(&program: ProgramName; location: Int32; var ¶ms: UInt32) :=
z_GetUniformuiv_ovr_0(&program, location, ¶ms);
private z_GetUniformuiv_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; ¶ms: IntPtr)>(z_GetUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuiv(&program: ProgramName; location: Int32; ¶ms: IntPtr) :=
z_GetUniformuiv_ovr_2(&program, location, ¶ms);
// added in gl4.5
private z_GetVertexArrayIndexed64iv_adr := GetFuncAdr('glGetVertexArrayIndexed64iv');
private z_GetVertexArrayIndexed64iv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64)>(z_GetVertexArrayIndexed64iv_adr);
private z_GetVertexArrayIndexed64iv_ovr_0_anh00001 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIndexed64iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int64) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayIndexed64iv_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64) :=
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param);
private z_GetVertexArrayIndexed64iv_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIndexed64iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIndexed64iv_ovr_2(vaobj, index, pname, param);
// added in gl4.5
private z_GetVertexArrayIndexediv_adr := GetFuncAdr('glGetVertexArrayIndexediv');
private z_GetVertexArrayIndexediv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayIndexediv_adr);
private z_GetVertexArrayIndexediv_ovr_0_anh00001 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayIndexediv_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param);
private z_GetVertexArrayIndexediv_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIndexediv_ovr_2(vaobj, index, pname, param);
// added in gl4.5
private z_GetVertexArrayiv_adr := GetFuncAdr('glGetVertexArrayiv');
private z_GetVertexArrayiv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayiv_adr);
private z_GetVertexArrayiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayiv_ovr_0(vaobj, pname, param[0]) else
z_GetVertexArrayiv_ovr_0_anh0001(vaobj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayiv_ovr_0(vaobj, pname, param);
private z_GetVertexArrayiv_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayiv_ovr_2(vaobj, pname, param);
// added in gl2.0
private z_GetVertexAttribdv_adr := GetFuncAdr('glGetVertexAttribdv');
private z_GetVertexAttribdv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real)>(z_GetVertexAttribdv_adr);
private z_GetVertexAttribdv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribdv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribdv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real) :=
z_GetVertexAttribdv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribdv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribdv_ovr_2(index, pname, ¶ms);
// added in gl2.0
private z_GetVertexAttribfv_adr := GetFuncAdr('glGetVertexAttribfv');
private z_GetVertexAttribfv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single)>(z_GetVertexAttribfv_adr);
private z_GetVertexAttribfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribfv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribfv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single) :=
z_GetVertexAttribfv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribfv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribfv_ovr_2(index, pname, ¶ms);
// added in gl3.0
private z_GetVertexAttribIiv_adr := GetFuncAdr('glGetVertexAttribIiv');
private z_GetVertexAttribIiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32)>(z_GetVertexAttribIiv_adr);
private z_GetVertexAttribIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIiv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribIiv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribIiv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIiv(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32) :=
z_GetVertexAttribIiv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribIiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIiv(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribIiv_ovr_2(index, pname, ¶ms);
// added in gl3.0
private z_GetVertexAttribIuiv_adr := GetFuncAdr('glGetVertexAttribIuiv');
private z_GetVertexAttribIuiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32)>(z_GetVertexAttribIuiv_adr);
private z_GetVertexAttribIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuiv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribIuiv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribIuiv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuiv(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32) :=
z_GetVertexAttribIuiv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribIuiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuiv(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribIuiv_ovr_2(index, pname, ¶ms);
// added in gl2.0
private z_GetVertexAttribiv_adr := GetFuncAdr('glGetVertexAttribiv');
private z_GetVertexAttribiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32)>(z_GetVertexAttribiv_adr);
private z_GetVertexAttribiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribiv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribiv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribiv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribiv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32) :=
z_GetVertexAttribiv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribiv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribiv_ovr_2(index, pname, ¶ms);
// added in gl4.1
private z_GetVertexAttribLdv_adr := GetFuncAdr('glGetVertexAttribLdv');
private z_GetVertexAttribLdv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: real)>(z_GetVertexAttribLdv_adr);
private z_GetVertexAttribLdv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLdv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; var ¶ms: real) :=
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms);
private z_GetVertexAttribLdv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLdv_ovr_2(index, pname, ¶ms);
// added in gl2.0
private z_GetVertexAttribPointerv_adr := GetFuncAdr('glGetVertexAttribPointerv');
private z_GetVertexAttribPointerv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr)>(z_GetVertexAttribPointerv_adr);
private z_GetVertexAttribPointerv_ovr_0_anh0001 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: IntPtr)>(z_GetVertexAttribPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointerv(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_GetVertexAttribPointerv_ovr_0(index, pname, _pointer[0]) else
z_GetVertexAttribPointerv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointerv(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr) :=
z_GetVertexAttribPointerv_ovr_0(index, pname, _pointer);
private z_GetVertexAttribPointerv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer)>(z_GetVertexAttribPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointerv(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer) :=
z_GetVertexAttribPointerv_ovr_2(index, pname, _pointer);
// added in gl1.0
private static procedure z_Hint_ovr_0(target: HintTarget; mode: HintMode);
external 'opengl32.dll' name 'glHint';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Hint(target: HintTarget; mode: HintMode) :=
z_Hint_ovr_0(target, mode);
// added in gl4.3
private z_InvalidateBufferData_adr := GetFuncAdr('glInvalidateBufferData');
private z_InvalidateBufferData_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName)>(z_InvalidateBufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateBufferData(buffer: BufferName) :=
z_InvalidateBufferData_ovr_0(buffer);
// added in gl4.3
private z_InvalidateBufferSubData_adr := GetFuncAdr('glInvalidateBufferSubData');
private z_InvalidateBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName; offset: IntPtr; length: IntPtr)>(z_InvalidateBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateBufferSubData(buffer: BufferName; offset: IntPtr; length: IntPtr) :=
z_InvalidateBufferSubData_ovr_0(buffer, offset, length);
// added in gl4.3
private z_InvalidateFramebuffer_adr := GetFuncAdr('glInvalidateFramebuffer');
private z_InvalidateFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment)>(z_InvalidateFramebuffer_adr);
private z_InvalidateFramebuffer_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr)>(z_InvalidateFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: array of InvalidateFramebufferAttachment) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments[0]) else
z_InvalidateFramebuffer_ovr_0_anh0001(target, numAttachments, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment) :=
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments);
private z_InvalidateFramebuffer_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr)>(z_InvalidateFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr) :=
z_InvalidateFramebuffer_ovr_2(target, numAttachments, attachments);
// added in gl4.5
private z_InvalidateNamedFramebufferData_adr := GetFuncAdr('glInvalidateNamedFramebufferData');
private z_InvalidateNamedFramebufferData_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment)>(z_InvalidateNamedFramebufferData_adr);
private z_InvalidateNamedFramebufferData_ovr_0_anh0001 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr)>(z_InvalidateNamedFramebufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; attachments: array of FramebufferAttachment) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments[0]) else
z_InvalidateNamedFramebufferData_ovr_0_anh0001(framebuffer, numAttachments, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment) :=
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments);
private z_InvalidateNamedFramebufferData_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr)>(z_InvalidateNamedFramebufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr) :=
z_InvalidateNamedFramebufferData_ovr_2(framebuffer, numAttachments, attachments);
// added in gl4.5
private z_InvalidateNamedFramebufferSubData_adr := GetFuncAdr('glInvalidateNamedFramebufferSubData');
private z_InvalidateNamedFramebufferSubData_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateNamedFramebufferSubData_adr);
private z_InvalidateNamedFramebufferSubData_ovr_0_anh00010000 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateNamedFramebufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; attachments: array of FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments[0], x, y, width, height) else
z_InvalidateNamedFramebufferSubData_ovr_0_anh00010000(framebuffer, numAttachments, IntPtr.Zero, x, y, width, height);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments, x, y, width, height);
private z_InvalidateNamedFramebufferSubData_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateNamedFramebufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateNamedFramebufferSubData_ovr_2(framebuffer, numAttachments, attachments, x, y, width, height);
// added in gl4.3
private z_InvalidateSubFramebuffer_adr := GetFuncAdr('glInvalidateSubFramebuffer');
private z_InvalidateSubFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateSubFramebuffer_adr);
private z_InvalidateSubFramebuffer_ovr_0_anh00010000 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateSubFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: array of InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments[0], x, y, width, height) else
z_InvalidateSubFramebuffer_ovr_0_anh00010000(target, numAttachments, IntPtr.Zero, x, y, width, height);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments, x, y, width, height);
private z_InvalidateSubFramebuffer_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32)>(z_InvalidateSubFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateSubFramebuffer_ovr_2(target, numAttachments, attachments, x, y, width, height);
// added in gl4.3
private z_InvalidateTexImage_adr := GetFuncAdr('glInvalidateTexImage');
private z_InvalidateTexImage_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32)>(z_InvalidateTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateTexImage(texture: TextureName; level: Int32) :=
z_InvalidateTexImage_ovr_0(texture, level);
// added in gl4.3
private z_InvalidateTexSubImage_adr := GetFuncAdr('glInvalidateTexSubImage');
private z_InvalidateTexSubImage_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32)>(z_InvalidateTexSubImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateTexSubImage(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32) :=
z_InvalidateTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth);
// added in gl1.5
private z_IsBuffer_adr := GetFuncAdr('glIsBuffer');
private z_IsBuffer_ovr_0 := GetFuncOrNil&<function(buffer: BufferName): boolean>(z_IsBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBuffer(buffer: BufferName): boolean :=
z_IsBuffer_ovr_0(buffer);
// added in gl1.0
private static function z_IsEnabled_ovr_0(cap: EnableCap): boolean;
external 'opengl32.dll' name 'glIsEnabled';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabled(cap: EnableCap): boolean :=
z_IsEnabled_ovr_0(cap);
// added in gl3.0
private z_IsEnabledi_adr := GetFuncAdr('glIsEnabledi');
private z_IsEnabledi_ovr_0 := GetFuncOrNil&<function(target: EnableCap; index: UInt32): boolean>(z_IsEnabledi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabledi(target: EnableCap; index: UInt32): boolean :=
z_IsEnabledi_ovr_0(target, index);
// added in gl3.0
private z_IsFramebuffer_adr := GetFuncAdr('glIsFramebuffer');
private z_IsFramebuffer_ovr_0 := GetFuncOrNil&<function(framebuffer: FramebufferName): boolean>(z_IsFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFramebuffer(framebuffer: FramebufferName): boolean :=
z_IsFramebuffer_ovr_0(framebuffer);
// added in gl2.0
private z_IsProgram_adr := GetFuncAdr('glIsProgram');
private z_IsProgram_ovr_0 := GetFuncOrNil&<function(&program: ProgramName): boolean>(z_IsProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgram(&program: ProgramName): boolean :=
z_IsProgram_ovr_0(&program);
// added in gl4.1
private z_IsProgramPipeline_adr := GetFuncAdr('glIsProgramPipeline');
private z_IsProgramPipeline_ovr_0 := GetFuncOrNil&<function(pipeline: ProgramPipelineName): boolean>(z_IsProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramPipeline(pipeline: ProgramPipelineName): boolean :=
z_IsProgramPipeline_ovr_0(pipeline);
// added in gl1.5
private z_IsQuery_adr := GetFuncAdr('glIsQuery');
private z_IsQuery_ovr_0 := GetFuncOrNil&<function(id: QueryName): boolean>(z_IsQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsQuery(id: QueryName): boolean :=
z_IsQuery_ovr_0(id);
// added in gl3.0
private z_IsRenderbuffer_adr := GetFuncAdr('glIsRenderbuffer');
private z_IsRenderbuffer_ovr_0 := GetFuncOrNil&<function(renderbuffer: RenderbufferName): boolean>(z_IsRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsRenderbuffer(renderbuffer: RenderbufferName): boolean :=
z_IsRenderbuffer_ovr_0(renderbuffer);
// added in gl3.3
private z_IsSampler_adr := GetFuncAdr('glIsSampler');
private z_IsSampler_ovr_0 := GetFuncOrNil&<function(sampler: SamplerName): boolean>(z_IsSampler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSampler(sampler: SamplerName): boolean :=
z_IsSampler_ovr_0(sampler);
// added in gl2.0
private z_IsShader_adr := GetFuncAdr('glIsShader');
private z_IsShader_ovr_0 := GetFuncOrNil&<function(shader: ShaderName): boolean>(z_IsShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsShader(shader: ShaderName): boolean :=
z_IsShader_ovr_0(shader);
// added in gl3.2
private z_IsSync_adr := GetFuncAdr('glIsSync');
private z_IsSync_ovr_0 := GetFuncOrNil&<function(sync: GLsync): boolean>(z_IsSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSync(sync: GLsync): boolean :=
z_IsSync_ovr_0(sync);
// added in gl1.1
private static function z_IsTexture_ovr_0(texture: TextureName): boolean;
external 'opengl32.dll' name 'glIsTexture';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTexture(texture: TextureName): boolean :=
z_IsTexture_ovr_0(texture);
// added in gl4.0
private z_IsTransformFeedback_adr := GetFuncAdr('glIsTransformFeedback');
private z_IsTransformFeedback_ovr_0 := GetFuncOrNil&<function(id: TransformFeedbackName): boolean>(z_IsTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTransformFeedback(id: TransformFeedbackName): boolean :=
z_IsTransformFeedback_ovr_0(id);
// added in gl3.0
private z_IsVertexArray_adr := GetFuncAdr('glIsVertexArray');
private z_IsVertexArray_ovr_0 := GetFuncOrNil&<function(&array: VertexArrayName): boolean>(z_IsVertexArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexArray(&array: VertexArrayName): boolean :=
z_IsVertexArray_ovr_0(&array);
// added in gl1.0
private static procedure z_LineWidth_ovr_0(width: single);
external 'opengl32.dll' name 'glLineWidth';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineWidth(width: single) :=
z_LineWidth_ovr_0(width);
// added in gl2.0
private z_LinkProgram_adr := GetFuncAdr('glLinkProgram');
private z_LinkProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_LinkProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LinkProgram(&program: ProgramName) :=
z_LinkProgram_ovr_0(&program);
// added in gl1.0
private static procedure z_LogicOp_ovr_0(opcode: OpenGL.LogicOp);
external 'opengl32.dll' name 'glLogicOp';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LogicOp(opcode: OpenGL.LogicOp) :=
z_LogicOp_ovr_0(opcode);
// added in gl1.5
private z_MapBuffer_adr := GetFuncAdr('glMapBuffer');
private z_MapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; access: BufferAccessARB): IntPtr>(z_MapBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBuffer(target: BufferTargetARB; access: BufferAccessARB): IntPtr :=
z_MapBuffer_ovr_0(target, access);
// added in gl3.0
private z_MapBufferRange_adr := GetFuncAdr('glMapBufferRange');
private z_MapBufferRange_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
z_MapBufferRange_ovr_0(target, offset, length, access);
// added in gl4.5
private z_MapNamedBuffer_adr := GetFuncAdr('glMapNamedBuffer');
private z_MapNamedBuffer_ovr_0 := GetFuncOrNil&<function(buffer: BufferName; access: BufferAccessARB): IntPtr>(z_MapNamedBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBuffer(buffer: BufferName; access: BufferAccessARB): IntPtr :=
z_MapNamedBuffer_ovr_0(buffer, access);
// added in gl4.5
private z_MapNamedBufferRange_adr := GetFuncAdr('glMapNamedBufferRange');
private z_MapNamedBufferRange_ovr_0 := GetFuncOrNil&<function(buffer: BufferName; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapNamedBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferRange(buffer: BufferName; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
z_MapNamedBufferRange_ovr_0(buffer, offset, length, access);
// added in gl4.2
private z_MemoryBarrier_adr := GetFuncAdr('glMemoryBarrier');
private z_MemoryBarrier_ovr_0 := GetFuncOrNil&<procedure(barriers: MemoryBarrierMask)>(z_MemoryBarrier_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrier(barriers: MemoryBarrierMask) :=
z_MemoryBarrier_ovr_0(barriers);
// added in gl4.5
private z_MemoryBarrierByRegion_adr := GetFuncAdr('glMemoryBarrierByRegion');
private z_MemoryBarrierByRegion_ovr_0 := GetFuncOrNil&<procedure(barriers: MemoryBarrierMask)>(z_MemoryBarrierByRegion_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrierByRegion(barriers: MemoryBarrierMask) :=
z_MemoryBarrierByRegion_ovr_0(barriers);
// added in gl4.0
private z_MinSampleShading_adr := GetFuncAdr('glMinSampleShading');
private z_MinSampleShading_ovr_0 := GetFuncOrNil&<procedure(value: single)>(z_MinSampleShading_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinSampleShading(value: single) :=
z_MinSampleShading_ovr_0(value);
// added in gl1.4
private z_MultiDrawArrays_adr := GetFuncAdr('glMultiDrawArrays');
private z_MultiDrawArrays_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
private z_MultiDrawArrays_ovr_0_anh00100 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
private z_MultiDrawArrays_ovr_0_anh00010 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
private z_MultiDrawArrays_ovr_0_anh00110 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; count: array of Int32; drawcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArrays_ovr_0(mode, first[0], count[0], drawcount) else
z_MultiDrawArrays_ovr_0_anh00010(mode, first[0], IntPtr.Zero, drawcount) else
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArrays_ovr_0_anh00100(mode, IntPtr.Zero, count[0], drawcount) else
z_MultiDrawArrays_ovr_0_anh00110(mode, IntPtr.Zero, IntPtr.Zero, drawcount);
private z_MultiDrawArrays_ovr_1_anh00100 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; var count: Int32; drawcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawArrays_ovr_0(mode, first[0], count, drawcount) else
z_MultiDrawArrays_ovr_0_anh00100(mode, IntPtr.Zero, count, drawcount);
private z_MultiDrawArrays_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
private z_MultiDrawArrays_ovr_2_anh00100 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; count: IntPtr; drawcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawArrays_ovr_2(mode, first[0], count, drawcount) else
z_MultiDrawArrays_ovr_2_anh00100(mode, IntPtr.Zero, count, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; count: array of Int32; drawcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArrays_ovr_0(mode, first, count[0], drawcount) else
z_MultiDrawArrays_ovr_0_anh00010(mode, first, IntPtr.Zero, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; var count: Int32; drawcount: Int32) :=
z_MultiDrawArrays_ovr_0(mode, first, count, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; count: IntPtr; drawcount: Int32) :=
z_MultiDrawArrays_ovr_2(mode, first, count, drawcount);
private z_MultiDrawArrays_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
private z_MultiDrawArrays_ovr_6_anh00010 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: IntPtr; count: array of Int32; drawcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArrays_ovr_6(mode, first, count[0], drawcount) else
z_MultiDrawArrays_ovr_6_anh00010(mode, first, IntPtr.Zero, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32) :=
z_MultiDrawArrays_ovr_6(mode, first, count, drawcount);
private z_MultiDrawArrays_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: IntPtr; count: IntPtr; drawcount: Int32) :=
z_MultiDrawArrays_ovr_8(mode, first, count, drawcount);
// added in gl4.3
private z_MultiDrawArraysIndirect_adr := GetFuncAdr('glMultiDrawArraysIndirect');
private z_MultiDrawArraysIndirect_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; drawcount: Int32; stride: Int32)>(z_MultiDrawArraysIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirect(mode: PrimitiveType; indirect: IntPtr; drawcount: Int32; stride: Int32) :=
z_MultiDrawArraysIndirect_ovr_0(mode, indirect, drawcount, stride);
// added in gl4.6
private z_MultiDrawArraysIndirectCount_adr := GetFuncAdr('glMultiDrawArraysIndirectCount');
private z_MultiDrawArraysIndirectCount_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32)>(z_MultiDrawArraysIndirectCount_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectCount(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32) :=
z_MultiDrawArraysIndirectCount_ovr_0(mode, indirect, drawcount, maxdrawcount, stride);
// added in gl1.4
private z_MultiDrawElements_adr := GetFuncAdr('glMultiDrawElements');
private z_MultiDrawElements_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
private z_MultiDrawElements_ovr_0_anh001000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
private z_MultiDrawElements_ovr_0_anh000010 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
private z_MultiDrawElements_ovr_0_anh001010 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElements_ovr_0(mode, count[0], &type, indices[0], drawcount) else
z_MultiDrawElements_ovr_0_anh000010(mode, count[0], &type, IntPtr.Zero, drawcount) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElements_ovr_0_anh001000(mode, IntPtr.Zero, &type, indices[0], drawcount) else
z_MultiDrawElements_ovr_0_anh001010(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount);
private z_MultiDrawElements_ovr_1_anh001000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElements_ovr_0(mode, count[0], &type, indices, drawcount) else
z_MultiDrawElements_ovr_0_anh001000(mode, IntPtr.Zero, &type, indices, drawcount);
private z_MultiDrawElements_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32)>(z_MultiDrawElements_adr);
private z_MultiDrawElements_ovr_2_anh001000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElements_ovr_2(mode, count[0], &type, indices, drawcount) else
z_MultiDrawElements_ovr_2_anh001000(mode, IntPtr.Zero, &type, indices, drawcount);
private z_MultiDrawElements_ovr_3_anh000010 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElements_ovr_0(mode, count, &type, indices[0], drawcount) else
z_MultiDrawElements_ovr_0_anh000010(mode, count, &type, IntPtr.Zero, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32) :=
z_MultiDrawElements_ovr_0(mode, count, &type, indices, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32) :=
z_MultiDrawElements_ovr_2(mode, count, &type, indices, drawcount);
private z_MultiDrawElements_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
private z_MultiDrawElements_ovr_6_anh000010 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElements_ovr_6(mode, count, &type, indices[0], drawcount) else
z_MultiDrawElements_ovr_6_anh000010(mode, count, &type, IntPtr.Zero, drawcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32) :=
z_MultiDrawElements_ovr_6(mode, count, &type, indices, drawcount);
private z_MultiDrawElements_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32)>(z_MultiDrawElements_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32) :=
z_MultiDrawElements_ovr_8(mode, count, &type, indices, drawcount);
// added in gl3.2
private z_MultiDrawElementsBaseVertex_adr := GetFuncAdr('glMultiDrawElementsBaseVertex');
private z_MultiDrawElementsBaseVertex_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0010100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0000001 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0010001 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0000101 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_0_anh0010101 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count[0], &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000101(mode, count[0], &type, IntPtr.Zero, drawcount, IntPtr.Zero) else
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010001(mode, IntPtr.Zero, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010101(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private z_MultiDrawElementsBaseVertex_ovr_1_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_1_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_1_anh0010100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_2_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_2_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_2_anh0010100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_3_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_3_anh0010001 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count[0], &type, indices, drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010001(mode, IntPtr.Zero, &type, indices, drawcount, IntPtr.Zero);
private z_MultiDrawElementsBaseVertex_ovr_4_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_5_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_6_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_6_anh0000001 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_6_anh0010001 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0000001(mode, count[0], &type, indices, drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0010001(mode, IntPtr.Zero, &type, indices, drawcount, IntPtr.Zero);
private z_MultiDrawElementsBaseVertex_ovr_7_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_8_anh0010000 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_8(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_8_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_9_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_9_anh0000101 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000101(mode, count, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private z_MultiDrawElementsBaseVertex_ovr_10_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_11_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_8(mode, count, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_18 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_18_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_18_anh0000001 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_18_anh0000101 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000001(mode, count, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000101(mode, count, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private z_MultiDrawElementsBaseVertex_ovr_19_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_20 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_20_anh0000100 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_20_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_24 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32)>(z_MultiDrawElementsBaseVertex_adr);
private z_MultiDrawElementsBaseVertex_ovr_24_anh0000001 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_24_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex);
private z_MultiDrawElementsBaseVertex_ovr_26 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr)>(z_MultiDrawElementsBaseVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_26(mode, count, &type, indices, drawcount, basevertex);
// added in gl4.3
private z_MultiDrawElementsIndirect_adr := GetFuncAdr('glMultiDrawElementsIndirect');
private z_MultiDrawElementsIndirect_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: Int32; stride: Int32)>(z_MultiDrawElementsIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirect(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: Int32; stride: Int32) :=
z_MultiDrawElementsIndirect_ovr_0(mode, &type, indirect, drawcount, stride);
// added in gl4.6
private z_MultiDrawElementsIndirectCount_adr := GetFuncAdr('glMultiDrawElementsIndirectCount');
private z_MultiDrawElementsIndirectCount_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32)>(z_MultiDrawElementsIndirectCount_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectCount(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32) :=
z_MultiDrawElementsIndirectCount_ovr_0(mode, &type, indirect, drawcount, maxdrawcount, stride);
// added in gl3.3
private z_MultiTexCoordP1ui_adr := GetFuncAdr('glMultiTexCoordP1ui');
private z_MultiTexCoordP1ui_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32)>(z_MultiTexCoordP1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP1ui_ovr_0(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP1uiv_adr := GetFuncAdr('glMultiTexCoordP1uiv');
private z_MultiTexCoordP1uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP1uiv_adr);
private z_MultiTexCoordP1uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP1uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords);
private z_MultiTexCoordP1uiv_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP1uiv_ovr_2(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP2ui_adr := GetFuncAdr('glMultiTexCoordP2ui');
private z_MultiTexCoordP2ui_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32)>(z_MultiTexCoordP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP2ui_ovr_0(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP2uiv_adr := GetFuncAdr('glMultiTexCoordP2uiv');
private z_MultiTexCoordP2uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP2uiv_adr);
private z_MultiTexCoordP2uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP2uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords);
private z_MultiTexCoordP2uiv_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP2uiv_ovr_2(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP3ui_adr := GetFuncAdr('glMultiTexCoordP3ui');
private z_MultiTexCoordP3ui_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32)>(z_MultiTexCoordP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP3ui_ovr_0(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP3uiv_adr := GetFuncAdr('glMultiTexCoordP3uiv');
private z_MultiTexCoordP3uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP3uiv_adr);
private z_MultiTexCoordP3uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP3uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords);
private z_MultiTexCoordP3uiv_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP3uiv_ovr_2(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP4ui_adr := GetFuncAdr('glMultiTexCoordP4ui');
private z_MultiTexCoordP4ui_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32)>(z_MultiTexCoordP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP4ui_ovr_0(texture, &type, coords);
// added in gl3.3
private z_MultiTexCoordP4uiv_adr := GetFuncAdr('glMultiTexCoordP4uiv');
private z_MultiTexCoordP4uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP4uiv_adr);
private z_MultiTexCoordP4uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP4uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords);
private z_MultiTexCoordP4uiv_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr)>(z_MultiTexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP4uiv_ovr_2(texture, &type, coords);
// added in gl4.5
private z_NamedBufferData_adr := GetFuncAdr('glNamedBufferData');
private z_NamedBufferData_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName; size: IntPtr; var data: Byte; usage: VertexBufferObjectUsage)>(z_NamedBufferData_adr);
private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferData_ovr_0<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage); where T: record;
begin
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
end;
private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferData_ovr_0_anh00010(buffer: BufferName; size: IntPtr; usage: VertexBufferObjectUsage) :=
z_NamedBufferData_ovr_0(buffer, size, PByte(nil)^, usage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; data: array of T; usage: VertexBufferObjectUsage); where T: record;
begin
if (data<>nil) and (data.Length<>0) then
temp_NamedBufferData_ovr_0(buffer, size, data[0], usage) else
temp_NamedBufferData_ovr_0_anh00010(buffer, size, usage);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage); where T: record;
begin
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
end;
private z_NamedBufferData_ovr_2 := GetFuncOrNil&<procedure(buffer: BufferName; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage)>(z_NamedBufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData(buffer: BufferName; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage) :=
z_NamedBufferData_ovr_2(buffer, size, data, usage);
// added in gl4.5
private z_NamedBufferStorage_adr := GetFuncAdr('glNamedBufferStorage');
private z_NamedBufferStorage_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName; size: IntPtr; data: IntPtr; flags: BufferStorageMask)>(z_NamedBufferStorage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorage(buffer: BufferName; size: IntPtr; data: IntPtr; flags: BufferStorageMask) :=
z_NamedBufferStorage_ovr_0(buffer, size, data, flags);
// added in gl4.5
private z_NamedBufferSubData_adr := GetFuncAdr('glNamedBufferSubData');
private z_NamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_NamedBufferSubData_ovr_0(buffer, offset, size, data);
// added in gl4.5
private z_NamedFramebufferDrawBuffer_adr := GetFuncAdr('glNamedFramebufferDrawBuffer');
private z_NamedFramebufferDrawBuffer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; buf: ColorBuffer)>(z_NamedFramebufferDrawBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffer(framebuffer: FramebufferName; buf: ColorBuffer) :=
z_NamedFramebufferDrawBuffer_ovr_0(framebuffer, buf);
// added in gl4.5
private z_NamedFramebufferDrawBuffers_adr := GetFuncAdr('glNamedFramebufferDrawBuffers');
private z_NamedFramebufferDrawBuffers_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer)>(z_NamedFramebufferDrawBuffers_adr);
private z_NamedFramebufferDrawBuffers_ovr_0_anh0001 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; bufs: IntPtr)>(z_NamedFramebufferDrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; bufs: array of ColorBuffer) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs[0]) else
z_NamedFramebufferDrawBuffers_ovr_0_anh0001(framebuffer, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer) :=
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs);
private z_NamedFramebufferDrawBuffers_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; bufs: IntPtr)>(z_NamedFramebufferDrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; bufs: IntPtr) :=
z_NamedFramebufferDrawBuffers_ovr_2(framebuffer, n, bufs);
// added in gl4.5
private z_NamedFramebufferParameteri_adr := GetFuncAdr('glNamedFramebufferParameteri');
private z_NamedFramebufferParameteri_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; pname: FramebufferParameterName; param: Int32)>(z_NamedFramebufferParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferParameteri(framebuffer: FramebufferName; pname: FramebufferParameterName; param: Int32) :=
z_NamedFramebufferParameteri_ovr_0(framebuffer, pname, param);
// added in gl4.5
private z_NamedFramebufferReadBuffer_adr := GetFuncAdr('glNamedFramebufferReadBuffer');
private z_NamedFramebufferReadBuffer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; src: ColorBuffer)>(z_NamedFramebufferReadBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferReadBuffer(framebuffer: FramebufferName; src: ColorBuffer) :=
z_NamedFramebufferReadBuffer_ovr_0(framebuffer, src);
// added in gl4.5
private z_NamedFramebufferRenderbuffer_adr := GetFuncAdr('glNamedFramebufferRenderbuffer');
private z_NamedFramebufferRenderbuffer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName)>(z_NamedFramebufferRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferRenderbuffer(framebuffer: FramebufferName; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_NamedFramebufferRenderbuffer_ovr_0(framebuffer, attachment, _renderbuffertarget, renderbuffer);
// added in gl4.5
private z_NamedFramebufferTexture_adr := GetFuncAdr('glNamedFramebufferTexture');
private z_NamedFramebufferTexture_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32)>(z_NamedFramebufferTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32) :=
z_NamedFramebufferTexture_ovr_0(framebuffer, attachment, texture, level);
// added in gl4.5
private z_NamedFramebufferTextureLayer_adr := GetFuncAdr('glNamedFramebufferTextureLayer');
private z_NamedFramebufferTextureLayer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32)>(z_NamedFramebufferTextureLayer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureLayer(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32) :=
z_NamedFramebufferTextureLayer_ovr_0(framebuffer, attachment, texture, level, layer);
// added in gl4.5
private z_NamedRenderbufferStorage_adr := GetFuncAdr('glNamedRenderbufferStorage');
private z_NamedRenderbufferStorage_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: RenderbufferName; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorage(renderbuffer: RenderbufferName; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorage_ovr_0(renderbuffer, _internalformat, width, height);
// added in gl4.5
private z_NamedRenderbufferStorageMultisample_adr := GetFuncAdr('glNamedRenderbufferStorageMultisample');
private z_NamedRenderbufferStorageMultisample_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: RenderbufferName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorageMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisample(renderbuffer: RenderbufferName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageMultisample_ovr_0(renderbuffer, samples, _internalformat, width, height);
// added in gl3.3
private z_NormalP3ui_adr := GetFuncAdr('glNormalP3ui');
private z_NormalP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; coords: UInt32)>(z_NormalP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3ui(&type: NormalPointerType; coords: UInt32) :=
z_NormalP3ui_ovr_0(&type, coords);
// added in gl3.3
private z_NormalP3uiv_adr := GetFuncAdr('glNormalP3uiv');
private z_NormalP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; var coords: UInt32)>(z_NormalP3uiv_adr);
private z_NormalP3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: NormalPointerType; coords: IntPtr)>(z_NormalP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalP3uiv_ovr_0(&type, coords[0]) else
z_NormalP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; var coords: UInt32) :=
z_NormalP3uiv_ovr_0(&type, coords);
private z_NormalP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: NormalPointerType; coords: IntPtr)>(z_NormalP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: IntPtr) :=
z_NormalP3uiv_ovr_2(&type, coords);
// added in gl4.3
private z_ObjectLabel_adr := GetFuncAdr('glObjectLabel');
private z_ObjectLabel_ovr_0 := GetFuncOrNil&<procedure(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: IntPtr)>(z_ObjectLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectLabel(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(&label);
z_ObjectLabel_ovr_0(identifier, name, length, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectLabel(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: IntPtr) :=
z_ObjectLabel_ovr_0(identifier, name, length, &label);
// added in gl4.3
private z_ObjectPtrLabel_adr := GetFuncAdr('glObjectPtrLabel');
private z_ObjectPtrLabel_ovr_0 := GetFuncOrNil&<procedure(ptr: IntPtr; length: Int32; &label: IntPtr)>(z_ObjectPtrLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectPtrLabel(ptr: IntPtr; length: Int32; &label: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(&label);
z_ObjectPtrLabel_ovr_0(ptr, length, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectPtrLabel(ptr: IntPtr; length: Int32; &label: IntPtr) :=
z_ObjectPtrLabel_ovr_0(ptr, length, &label);
// added in gl4.0
private z_PatchParameterfv_adr := GetFuncAdr('glPatchParameterfv');
private z_PatchParameterfv_ovr_0 := GetFuncOrNil&<procedure(pname: PatchParameterName; var values: single)>(z_PatchParameterfv_adr);
private z_PatchParameterfv_ovr_0_anh001 := GetFuncOrNil&<procedure(pname: PatchParameterName; values: IntPtr)>(z_PatchParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_PatchParameterfv_ovr_0(pname, values[0]) else
z_PatchParameterfv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; var values: single) :=
z_PatchParameterfv_ovr_0(pname, values);
private z_PatchParameterfv_ovr_2 := GetFuncOrNil&<procedure(pname: PatchParameterName; values: IntPtr)>(z_PatchParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: IntPtr) :=
z_PatchParameterfv_ovr_2(pname, values);
// added in gl4.0
private z_PatchParameteri_adr := GetFuncAdr('glPatchParameteri');
private z_PatchParameteri_ovr_0 := GetFuncOrNil&<procedure(pname: PatchParameterName; value: Int32)>(z_PatchParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameteri(pname: PatchParameterName; value: Int32) :=
z_PatchParameteri_ovr_0(pname, value);
// added in gl4.0
private z_PauseTransformFeedback_adr := GetFuncAdr('glPauseTransformFeedback');
private z_PauseTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_PauseTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PauseTransformFeedback :=
z_PauseTransformFeedback_ovr_0;
// added in gl1.0
private static procedure z_PixelStoref_ovr_0(pname: PixelStoreParameter; param: single);
external 'opengl32.dll' name 'glPixelStoref';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelStoref(pname: PixelStoreParameter; param: single) :=
z_PixelStoref_ovr_0(pname, param);
// added in gl1.0
private static procedure z_PixelStorei_ovr_0(pname: PixelStoreParameter; param: Int32);
external 'opengl32.dll' name 'glPixelStorei';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelStorei(pname: PixelStoreParameter; param: Int32) :=
z_PixelStorei_ovr_0(pname, param);
// added in gl1.4
private z_PointParameterf_adr := GetFuncAdr('glPointParameterf');
private z_PointParameterf_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: single)>(z_PointParameterf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterf(pname: PointParameterNameARB; param: single) :=
z_PointParameterf_ovr_0(pname, param);
// added in gl1.4
private z_PointParameterfv_adr := GetFuncAdr('glPointParameterfv');
private z_PointParameterfv_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: single)>(z_PointParameterfv_adr);
private z_PointParameterfv_ovr_0_anh001 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterfv_ovr_0(pname, ¶ms[0]) else
z_PointParameterfv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; var ¶ms: single) :=
z_PointParameterfv_ovr_0(pname, ¶ms);
private z_PointParameterfv_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterfv_ovr_2(pname, ¶ms);
// added in gl1.4
private z_PointParameteri_adr := GetFuncAdr('glPointParameteri');
private z_PointParameteri_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: Int32)>(z_PointParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteri(pname: PointParameterNameARB; param: Int32) :=
z_PointParameteri_ovr_0(pname, param);
// added in gl1.4
private z_PointParameteriv_adr := GetFuncAdr('glPointParameteriv');
private z_PointParameteriv_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: Int32)>(z_PointParameteriv_adr);
private z_PointParameteriv_ovr_0_anh001 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameteriv_ovr_0(pname, ¶ms[0]) else
z_PointParameteriv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; var ¶ms: Int32) :=
z_PointParameteriv_ovr_0(pname, ¶ms);
private z_PointParameteriv_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameteriv_ovr_2(pname, ¶ms);
// added in gl1.0
private static procedure z_PointSize_ovr_0(size: single);
external 'opengl32.dll' name 'glPointSize';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointSize(size: single) :=
z_PointSize_ovr_0(size);
// added in gl1.0
private static procedure z_PolygonMode_ovr_0(face: MaterialFace; mode: OpenGL.PolygonMode);
external 'opengl32.dll' name 'glPolygonMode';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonMode(face: MaterialFace; mode: OpenGL.PolygonMode) :=
z_PolygonMode_ovr_0(face, mode);
// added in gl1.1
private static procedure z_PolygonOffset_ovr_0(factor: single; units: single);
external 'opengl32.dll' name 'glPolygonOffset';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffset(factor: single; units: single) :=
z_PolygonOffset_ovr_0(factor, units);
// added in gl4.6
private z_PolygonOffsetClamp_adr := GetFuncAdr('glPolygonOffsetClamp');
private z_PolygonOffsetClamp_ovr_0 := GetFuncOrNil&<procedure(factor: single; units: single; clamp: single)>(z_PolygonOffsetClamp_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetClamp(factor: single; units: single; clamp: single) :=
z_PolygonOffsetClamp_ovr_0(factor, units, clamp);
// added in gl4.3
private z_PopDebugGroup_adr := GetFuncAdr('glPopDebugGroup');
private z_PopDebugGroup_ovr_0 := GetFuncOrNil&<procedure>(z_PopDebugGroup_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopDebugGroup :=
z_PopDebugGroup_ovr_0;
// added in gl3.1
private z_PrimitiveRestartIndex_adr := GetFuncAdr('glPrimitiveRestartIndex');
private z_PrimitiveRestartIndex_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_PrimitiveRestartIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartIndex(index: UInt32) :=
z_PrimitiveRestartIndex_ovr_0(index);
// added in gl4.1
private z_ProgramBinary_adr := GetFuncAdr('glProgramBinary');
private z_ProgramBinary_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; binaryFormat: DummyEnum; binary: IntPtr; length: Int32)>(z_ProgramBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBinary(&program: UInt32; binaryFormat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ProgramBinary_ovr_0(&program, binaryFormat, binary, length);
// added in gl4.1
private z_ProgramParameteri_adr := GetFuncAdr('glProgramParameteri');
private z_ProgramParameteri_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; pname: ProgramParameterPName; value: Int32)>(z_ProgramParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteri(&program: ProgramName; pname: ProgramParameterPName; value: Int32) :=
z_ProgramParameteri_ovr_0(&program, pname, value);
// added in gl4.1
private z_ProgramUniform1d_adr := GetFuncAdr('glProgramUniform1d');
private z_ProgramUniform1d_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: real)>(z_ProgramUniform1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1d(&program: ProgramName; location: Int32; v0: real) :=
z_ProgramUniform1d_ovr_0(&program, location, v0);
// added in gl4.1
private z_ProgramUniform1dv_adr := GetFuncAdr('glProgramUniform1dv');
private z_ProgramUniform1dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform1dv_adr);
private z_ProgramUniform1dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform1dv_ovr_0(&program, location, count, value);
private z_ProgramUniform1dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1dv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform1f_adr := GetFuncAdr('glProgramUniform1f');
private z_ProgramUniform1f_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: single)>(z_ProgramUniform1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1f(&program: ProgramName; location: Int32; v0: single) :=
z_ProgramUniform1f_ovr_0(&program, location, v0);
// added in gl4.1
private z_ProgramUniform1fv_adr := GetFuncAdr('glProgramUniform1fv');
private z_ProgramUniform1fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform1fv_adr);
private z_ProgramUniform1fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform1fv_ovr_0(&program, location, count, value);
private z_ProgramUniform1fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1fv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform1i_adr := GetFuncAdr('glProgramUniform1i');
private z_ProgramUniform1i_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: Int32)>(z_ProgramUniform1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i(&program: ProgramName; location: Int32; v0: Int32) :=
z_ProgramUniform1i_ovr_0(&program, location, v0);
// added in gl4.1
private z_ProgramUniform1iv_adr := GetFuncAdr('glProgramUniform1iv');
private z_ProgramUniform1iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform1iv_adr);
private z_ProgramUniform1iv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform1iv_ovr_0(&program, location, count, value);
private z_ProgramUniform1iv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1iv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform1ui_adr := GetFuncAdr('glProgramUniform1ui');
private z_ProgramUniform1ui_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: UInt32)>(z_ProgramUniform1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui(&program: ProgramName; location: Int32; v0: UInt32) :=
z_ProgramUniform1ui_ovr_0(&program, location, v0);
// added in gl4.1
private z_ProgramUniform1uiv_adr := GetFuncAdr('glProgramUniform1uiv');
private z_ProgramUniform1uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform1uiv_adr);
private z_ProgramUniform1uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform1uiv_ovr_0(&program, location, count, value);
private z_ProgramUniform1uiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1uiv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform2d_adr := GetFuncAdr('glProgramUniform2d');
private z_ProgramUniform2d_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: real; v1: real)>(z_ProgramUniform2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2d(&program: ProgramName; location: Int32; v0: real; v1: real) :=
z_ProgramUniform2d_ovr_0(&program, location, v0, v1);
// added in gl4.1
private z_ProgramUniform2dv_adr := GetFuncAdr('glProgramUniform2dv');
private z_ProgramUniform2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform2dv_adr);
private z_ProgramUniform2dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform2dv_ovr_0(&program, location, count, value);
private z_ProgramUniform2dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2dv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform2f_adr := GetFuncAdr('glProgramUniform2f');
private z_ProgramUniform2f_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: single; v1: single)>(z_ProgramUniform2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2f(&program: ProgramName; location: Int32; v0: single; v1: single) :=
z_ProgramUniform2f_ovr_0(&program, location, v0, v1);
// added in gl4.1
private z_ProgramUniform2fv_adr := GetFuncAdr('glProgramUniform2fv');
private z_ProgramUniform2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform2fv_adr);
private z_ProgramUniform2fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform2fv_ovr_0(&program, location, count, value);
private z_ProgramUniform2fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2fv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform2i_adr := GetFuncAdr('glProgramUniform2i');
private z_ProgramUniform2i_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: Int32; v1: Int32)>(z_ProgramUniform2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32) :=
z_ProgramUniform2i_ovr_0(&program, location, v0, v1);
// added in gl4.1
private z_ProgramUniform2iv_adr := GetFuncAdr('glProgramUniform2iv');
private z_ProgramUniform2iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform2iv_adr);
private z_ProgramUniform2iv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform2iv_ovr_0(&program, location, count, value);
private z_ProgramUniform2iv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2iv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform2ui_adr := GetFuncAdr('glProgramUniform2ui');
private z_ProgramUniform2ui_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32)>(z_ProgramUniform2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32) :=
z_ProgramUniform2ui_ovr_0(&program, location, v0, v1);
// added in gl4.1
private z_ProgramUniform2uiv_adr := GetFuncAdr('glProgramUniform2uiv');
private z_ProgramUniform2uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform2uiv_adr);
private z_ProgramUniform2uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform2uiv_ovr_0(&program, location, count, value);
private z_ProgramUniform2uiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2uiv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform3d_adr := GetFuncAdr('glProgramUniform3d');
private z_ProgramUniform3d_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real)>(z_ProgramUniform3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3d(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real) :=
z_ProgramUniform3d_ovr_0(&program, location, v0, v1, v2);
// added in gl4.1
private z_ProgramUniform3dv_adr := GetFuncAdr('glProgramUniform3dv');
private z_ProgramUniform3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform3dv_adr);
private z_ProgramUniform3dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform3dv_ovr_0(&program, location, count, value);
private z_ProgramUniform3dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3dv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform3f_adr := GetFuncAdr('glProgramUniform3f');
private z_ProgramUniform3f_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single)>(z_ProgramUniform3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3f(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single) :=
z_ProgramUniform3f_ovr_0(&program, location, v0, v1, v2);
// added in gl4.1
private z_ProgramUniform3fv_adr := GetFuncAdr('glProgramUniform3fv');
private z_ProgramUniform3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform3fv_adr);
private z_ProgramUniform3fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform3fv_ovr_0(&program, location, count, value);
private z_ProgramUniform3fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3fv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform3i_adr := GetFuncAdr('glProgramUniform3i');
private z_ProgramUniform3i_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32)>(z_ProgramUniform3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32) :=
z_ProgramUniform3i_ovr_0(&program, location, v0, v1, v2);
// added in gl4.1
private z_ProgramUniform3iv_adr := GetFuncAdr('glProgramUniform3iv');
private z_ProgramUniform3iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform3iv_adr);
private z_ProgramUniform3iv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform3iv_ovr_0(&program, location, count, value);
private z_ProgramUniform3iv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3iv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform3ui_adr := GetFuncAdr('glProgramUniform3ui');
private z_ProgramUniform3ui_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32)>(z_ProgramUniform3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32) :=
z_ProgramUniform3ui_ovr_0(&program, location, v0, v1, v2);
// added in gl4.1
private z_ProgramUniform3uiv_adr := GetFuncAdr('glProgramUniform3uiv');
private z_ProgramUniform3uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform3uiv_adr);
private z_ProgramUniform3uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform3uiv_ovr_0(&program, location, count, value);
private z_ProgramUniform3uiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3uiv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform4d_adr := GetFuncAdr('glProgramUniform4d');
private z_ProgramUniform4d_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real; v3: real)>(z_ProgramUniform4d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4d(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real; v3: real) :=
z_ProgramUniform4d_ovr_0(&program, location, v0, v1, v2, v3);
// added in gl4.1
private z_ProgramUniform4dv_adr := GetFuncAdr('glProgramUniform4dv');
private z_ProgramUniform4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform4dv_adr);
private z_ProgramUniform4dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform4dv_ovr_0(&program, location, count, value);
private z_ProgramUniform4dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4dv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform4f_adr := GetFuncAdr('glProgramUniform4f');
private z_ProgramUniform4f_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single; v3: single)>(z_ProgramUniform4f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4f(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single; v3: single) :=
z_ProgramUniform4f_ovr_0(&program, location, v0, v1, v2, v3);
// added in gl4.1
private z_ProgramUniform4fv_adr := GetFuncAdr('glProgramUniform4fv');
private z_ProgramUniform4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform4fv_adr);
private z_ProgramUniform4fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform4fv_ovr_0(&program, location, count, value);
private z_ProgramUniform4fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4fv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform4i_adr := GetFuncAdr('glProgramUniform4i');
private z_ProgramUniform4i_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32)>(z_ProgramUniform4i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32) :=
z_ProgramUniform4i_ovr_0(&program, location, v0, v1, v2, v3);
// added in gl4.1
private z_ProgramUniform4iv_adr := GetFuncAdr('glProgramUniform4iv');
private z_ProgramUniform4iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform4iv_adr);
private z_ProgramUniform4iv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform4iv_ovr_0(&program, location, count, value);
private z_ProgramUniform4iv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4iv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniform4ui_adr := GetFuncAdr('glProgramUniform4ui');
private z_ProgramUniform4ui_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32)>(z_ProgramUniform4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32) :=
z_ProgramUniform4ui_ovr_0(&program, location, v0, v1, v2, v3);
// added in gl4.1
private z_ProgramUniform4uiv_adr := GetFuncAdr('glProgramUniform4uiv');
private z_ProgramUniform4uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform4uiv_adr);
private z_ProgramUniform4uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform4uiv_ovr_0(&program, location, count, value);
private z_ProgramUniform4uiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4uiv_ovr_2(&program, location, count, value);
// added in gl4.1
private z_ProgramUniformMatrix2dv_adr := GetFuncAdr('glProgramUniformMatrix2dv');
private z_ProgramUniformMatrix2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2dv_adr);
private z_ProgramUniformMatrix2dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix2fv_adr := GetFuncAdr('glProgramUniformMatrix2fv');
private z_ProgramUniformMatrix2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2fv_adr);
private z_ProgramUniformMatrix2fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix2x3dv_adr := GetFuncAdr('glProgramUniformMatrix2x3dv');
private z_ProgramUniformMatrix2x3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x3dv_adr);
private z_ProgramUniformMatrix2x3dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2x3dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix2x3fv_adr := GetFuncAdr('glProgramUniformMatrix2x3fv');
private z_ProgramUniformMatrix2x3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x3fv_adr);
private z_ProgramUniformMatrix2x3fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2x3fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix2x4dv_adr := GetFuncAdr('glProgramUniformMatrix2x4dv');
private z_ProgramUniformMatrix2x4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x4dv_adr);
private z_ProgramUniformMatrix2x4dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2x4dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix2x4fv_adr := GetFuncAdr('glProgramUniformMatrix2x4fv');
private z_ProgramUniformMatrix2x4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x4fv_adr);
private z_ProgramUniformMatrix2x4fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix2x4fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3dv_adr := GetFuncAdr('glProgramUniformMatrix3dv');
private z_ProgramUniformMatrix3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3dv_adr);
private z_ProgramUniformMatrix3dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3fv_adr := GetFuncAdr('glProgramUniformMatrix3fv');
private z_ProgramUniformMatrix3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3fv_adr);
private z_ProgramUniformMatrix3fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3x2dv_adr := GetFuncAdr('glProgramUniformMatrix3x2dv');
private z_ProgramUniformMatrix3x2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x2dv_adr);
private z_ProgramUniformMatrix3x2dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3x2dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3x2fv_adr := GetFuncAdr('glProgramUniformMatrix3x2fv');
private z_ProgramUniformMatrix3x2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x2fv_adr);
private z_ProgramUniformMatrix3x2fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3x2fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3x4dv_adr := GetFuncAdr('glProgramUniformMatrix3x4dv');
private z_ProgramUniformMatrix3x4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x4dv_adr);
private z_ProgramUniformMatrix3x4dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3x4dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix3x4fv_adr := GetFuncAdr('glProgramUniformMatrix3x4fv');
private z_ProgramUniformMatrix3x4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x4fv_adr);
private z_ProgramUniformMatrix3x4fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix3x4fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4dv_adr := GetFuncAdr('glProgramUniformMatrix4dv');
private z_ProgramUniformMatrix4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4dv_adr);
private z_ProgramUniformMatrix4dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4fv_adr := GetFuncAdr('glProgramUniformMatrix4fv');
private z_ProgramUniformMatrix4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4fv_adr);
private z_ProgramUniformMatrix4fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4x2dv_adr := GetFuncAdr('glProgramUniformMatrix4x2dv');
private z_ProgramUniformMatrix4x2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x2dv_adr);
private z_ProgramUniformMatrix4x2dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4x2dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4x2fv_adr := GetFuncAdr('glProgramUniformMatrix4x2fv');
private z_ProgramUniformMatrix4x2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x2fv_adr);
private z_ProgramUniformMatrix4x2fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4x2fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2fv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4x3dv_adr := GetFuncAdr('glProgramUniformMatrix4x3dv');
private z_ProgramUniformMatrix4x3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x3dv_adr);
private z_ProgramUniformMatrix4x3dv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4x3dv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3dv_ovr_2(&program, location, count, transpose, value);
// added in gl4.1
private z_ProgramUniformMatrix4x3fv_adr := GetFuncAdr('glProgramUniformMatrix4x3fv');
private z_ProgramUniformMatrix4x3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x3fv_adr);
private z_ProgramUniformMatrix4x3fv_ovr_0_anh000001 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value);
private z_ProgramUniformMatrix4x3fv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3fv_ovr_2(&program, location, count, transpose, value);
// added in gl3.2
private z_ProvokingVertex_adr := GetFuncAdr('glProvokingVertex');
private z_ProvokingVertex_ovr_0 := GetFuncOrNil&<procedure(mode: VertexProvokingMode)>(z_ProvokingVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProvokingVertex(mode: VertexProvokingMode) :=
z_ProvokingVertex_ovr_0(mode);
// added in gl4.3
private z_PushDebugGroup_adr := GetFuncAdr('glPushDebugGroup');
private z_PushDebugGroup_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; id: UInt32; length: Int32; message: IntPtr)>(z_PushDebugGroup_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushDebugGroup(source: DebugSource; id: UInt32; length: Int32; message: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(message);
z_PushDebugGroup_ovr_0(source, id, length, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushDebugGroup(source: DebugSource; id: UInt32; length: Int32; message: IntPtr) :=
z_PushDebugGroup_ovr_0(source, id, length, message);
// added in gl3.3
private z_QueryCounter_adr := GetFuncAdr('glQueryCounter');
private z_QueryCounter_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; target: QueryCounterTarget)>(z_QueryCounter_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryCounter(id: QueryName; target: QueryCounterTarget) :=
z_QueryCounter_ovr_0(id, target);
// added in gl1.0
private static procedure z_ReadBuffer_ovr_0(src: ReadBufferMode);
external 'opengl32.dll' name 'glReadBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadBuffer(src: ReadBufferMode) :=
z_ReadBuffer_ovr_0(src);
// added in gl4.5
private z_ReadnPixels_adr := GetFuncAdr('glReadnPixels');
private z_ReadnPixels_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr)>(z_ReadnPixels_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadnPixels(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr) :=
z_ReadnPixels_ovr_0(x, y, width, height, format, &type, bufSize, data);
// added in gl1.0
private static procedure z_ReadPixels_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glReadPixels';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadPixels(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_ReadPixels_ovr_0(x, y, width, height, format, &type, pixels);
// added in gl4.1
private z_ReleaseShaderCompiler_adr := GetFuncAdr('glReleaseShaderCompiler');
private z_ReleaseShaderCompiler_ovr_0 := GetFuncOrNil&<procedure>(z_ReleaseShaderCompiler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReleaseShaderCompiler :=
z_ReleaseShaderCompiler_ovr_0;
// added in gl3.0
private z_RenderbufferStorage_adr := GetFuncAdr('glRenderbufferStorage');
private z_RenderbufferStorage_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorage(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorage_ovr_0(target, _internalformat, width, height);
// added in gl3.0
private z_RenderbufferStorageMultisample_adr := GetFuncAdr('glRenderbufferStorageMultisample');
private z_RenderbufferStorageMultisample_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorageMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisample(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageMultisample_ovr_0(target, samples, _internalformat, width, height);
// added in gl4.0
private z_ResumeTransformFeedback_adr := GetFuncAdr('glResumeTransformFeedback');
private z_ResumeTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_ResumeTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResumeTransformFeedback :=
z_ResumeTransformFeedback_ovr_0;
// added in gl1.3
private z_SampleCoverage_adr := GetFuncAdr('glSampleCoverage');
private z_SampleCoverage_ovr_0 := GetFuncOrNil&<procedure(value: single; invert: boolean)>(z_SampleCoverage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleCoverage(value: single; invert: boolean) :=
z_SampleCoverage_ovr_0(value, invert);
// added in gl3.2
private z_SampleMaski_adr := GetFuncAdr('glSampleMaski');
private z_SampleMaski_ovr_0 := GetFuncOrNil&<procedure(maskNumber: UInt32; mask: DummyFlags)>(z_SampleMaski_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaski(maskNumber: UInt32; mask: DummyFlags) :=
z_SampleMaski_ovr_0(maskNumber, mask);
// added in gl3.3
private z_SamplerParameterf_adr := GetFuncAdr('glSamplerParameterf');
private z_SamplerParameterf_ovr_0 := GetFuncOrNil&<procedure(sampler: SamplerName; pname: OpenGL.SamplerParameterF; param: single)>(z_SamplerParameterf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterf(sampler: SamplerName; pname: OpenGL.SamplerParameterF; param: single) :=
z_SamplerParameterf_ovr_0(sampler, pname, param);
// added in gl3.3
private z_SamplerParameterfv_adr := GetFuncAdr('glSamplerParameterfv');
private z_SamplerParameterfv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single)>(z_SamplerParameterfv_adr);
private z_SamplerParameterfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr)>(z_SamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterfv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterfv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single) :=
z_SamplerParameterfv_ovr_0(sampler, pname, param);
private z_SamplerParameterfv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr)>(z_SamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr) :=
z_SamplerParameterfv_ovr_2(sampler, pname, param);
// added in gl3.3
private z_SamplerParameteri_adr := GetFuncAdr('glSamplerParameteri');
private z_SamplerParameteri_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: Int32)>(z_SamplerParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteri(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: Int32) :=
z_SamplerParameteri_ovr_0(sampler, pname, param);
// added in gl3.3
private z_SamplerParameterIiv_adr := GetFuncAdr('glSamplerParameterIiv');
private z_SamplerParameterIiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32)>(z_SamplerParameterIiv_adr);
private z_SamplerParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterIiv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterIiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32) :=
z_SamplerParameterIiv_ovr_0(sampler, pname, param);
private z_SamplerParameterIiv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameterIiv_ovr_2(sampler, pname, param);
// added in gl3.3
private z_SamplerParameterIuiv_adr := GetFuncAdr('glSamplerParameterIuiv');
private z_SamplerParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32)>(z_SamplerParameterIuiv_adr);
private z_SamplerParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of UInt32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterIuiv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterIuiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32) :=
z_SamplerParameterIuiv_ovr_0(sampler, pname, param);
private z_SamplerParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameterIuiv_ovr_2(sampler, pname, param);
// added in gl3.3
private z_SamplerParameteriv_adr := GetFuncAdr('glSamplerParameteriv');
private z_SamplerParameteriv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32)>(z_SamplerParameteriv_adr);
private z_SamplerParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameteriv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameteriv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32) :=
z_SamplerParameteriv_ovr_0(sampler, pname, param);
private z_SamplerParameteriv_ovr_2 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr)>(z_SamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameteriv_ovr_2(sampler, pname, param);
// added in gl1.0
private static procedure z_Scissor_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glScissor';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scissor(x: Int32; y: Int32; width: Int32; height: Int32) :=
z_Scissor_ovr_0(x, y, width, height);
// added in gl4.1
private z_ScissorArrayv_adr := GetFuncAdr('glScissorArrayv');
private z_ScissorArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: Int32)>(z_ScissorArrayv_adr);
private z_ScissorArrayv_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_ScissorArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_ScissorArrayv_ovr_0(first, count, v[0]) else
z_ScissorArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; var v: Int32) :=
z_ScissorArrayv_ovr_0(first, count, v);
private z_ScissorArrayv_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_ScissorArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_ScissorArrayv_ovr_2(first, count, v);
// added in gl4.1
private z_ScissorIndexed_adr := GetFuncAdr('glScissorIndexed');
private z_ScissorIndexed_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; left: Int32; bottom: Int32; width: Int32; height: Int32)>(z_ScissorIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexed(index: UInt32; left: Int32; bottom: Int32; width: Int32; height: Int32) :=
z_ScissorIndexed_ovr_0(index, left, bottom, width, height);
// added in gl4.1
private z_ScissorIndexedv_adr := GetFuncAdr('glScissorIndexedv');
private z_ScissorIndexedv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_ScissorIndexedv_adr);
private z_ScissorIndexedv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ScissorIndexedv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_ScissorIndexedv_ovr_0(index, v[0]) else
z_ScissorIndexedv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; var v: Int32) :=
z_ScissorIndexedv_ovr_0(index, v);
private z_ScissorIndexedv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ScissorIndexedv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: IntPtr) :=
z_ScissorIndexedv_ovr_2(index, v);
// added in gl3.3
private z_SecondaryColorP3ui_adr := GetFuncAdr('glSecondaryColorP3ui');
private z_SecondaryColorP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_SecondaryColorP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3ui(&type: ColorPointerType; color: UInt32) :=
z_SecondaryColorP3ui_ovr_0(&type, color);
// added in gl3.3
private z_SecondaryColorP3uiv_adr := GetFuncAdr('glSecondaryColorP3uiv');
private z_SecondaryColorP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_SecondaryColorP3uiv_adr);
private z_SecondaryColorP3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_SecondaryColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_SecondaryColorP3uiv_ovr_0(&type, color[0]) else
z_SecondaryColorP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; var color: UInt32) :=
z_SecondaryColorP3uiv_ovr_0(&type, color);
private z_SecondaryColorP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_SecondaryColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: IntPtr) :=
z_SecondaryColorP3uiv_ovr_2(&type, color);
// added in gl4.1
private z_ShaderBinary_adr := GetFuncAdr('glShaderBinary');
private z_ShaderBinary_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var shaders: UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32)>(z_ShaderBinary_adr);
private z_ShaderBinary_ovr_0_anh001000 := GetFuncOrNil&<procedure(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32)>(z_ShaderBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; shaders: array of UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
if (shaders<>nil) and (shaders.Length<>0) then
z_ShaderBinary_ovr_0(count, shaders[0], binaryformat, binary, length) else
z_ShaderBinary_ovr_0_anh001000(count, IntPtr.Zero, binaryformat, binary, length);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; var shaders: UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ShaderBinary_ovr_0(count, shaders, binaryformat, binary, length);
private z_ShaderBinary_ovr_2 := GetFuncOrNil&<procedure(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32)>(z_ShaderBinary_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ShaderBinary_ovr_2(count, shaders, binaryformat, binary, length);
// added in gl2.0
private z_ShaderSource_adr := GetFuncAdr('glShaderSource');
private z_ShaderSource_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; var _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_0_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_0_anh00001 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; var _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_0_anh00011 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of string; length: array of Int32);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_ShaderSource_ovr_0(shader, count, par_3_str_ptr[0], length[0]) else
z_ShaderSource_ovr_0_anh00001(shader, count, par_3_str_ptr[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_ShaderSource_ovr_0_anh00010(shader, count, IntPtr.Zero, length[0]) else
z_ShaderSource_ovr_0_anh00011(shader, count, IntPtr.Zero, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_ShaderSource_ovr_1_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of string; var length: Int32);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_ShaderSource_ovr_0(shader, count, par_3_str_ptr[0], length) else
z_ShaderSource_ovr_0_anh00010(shader, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_ShaderSource_ovr_2 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; var _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_2_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of string; length: IntPtr);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_ShaderSource_ovr_2(shader, count, par_3_str_ptr[0], length) else
z_ShaderSource_ovr_2_anh00010(shader, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_ShaderSource_ovr_3_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_3_anh00011 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; length: array of Int32) :=
if (_string<>nil) and (_string.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_ShaderSource_ovr_0(shader, count, _string[0], length[0]) else
z_ShaderSource_ovr_0_anh00001(shader, count, _string[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_ShaderSource_ovr_0_anh00010(shader, count, IntPtr.Zero, length[0]) else
z_ShaderSource_ovr_0_anh00011(shader, count, IntPtr.Zero, IntPtr.Zero);
private z_ShaderSource_ovr_4_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; var length: Int32) :=
if (_string<>nil) and (_string.Length<>0) then
z_ShaderSource_ovr_0(shader, count, _string[0], length) else
z_ShaderSource_ovr_0_anh00010(shader, count, IntPtr.Zero, length);
private z_ShaderSource_ovr_5_anh00010 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; length: IntPtr) :=
if (_string<>nil) and (_string.Length<>0) then
z_ShaderSource_ovr_2(shader, count, _string[0], length) else
z_ShaderSource_ovr_2_anh00010(shader, count, IntPtr.Zero, length);
private z_ShaderSource_ovr_6 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSource_adr);
private z_ShaderSource_ovr_6_anh00001 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: IntPtr; length: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
z_ShaderSource_ovr_6(shader, count, _string, length[0]) else
z_ShaderSource_ovr_6_anh00001(shader, count, _string, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32) :=
z_ShaderSource_ovr_6(shader, count, _string, length);
private z_ShaderSource_ovr_8 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: IntPtr; length: IntPtr) :=
z_ShaderSource_ovr_8(shader, count, _string, length);
// added in gl4.3
private z_ShaderStorageBlockBinding_adr := GetFuncAdr('glShaderStorageBlockBinding');
private z_ShaderStorageBlockBinding_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; storageBlockIndex: UInt32; storageBlockBinding: UInt32)>(z_ShaderStorageBlockBinding_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderStorageBlockBinding(&program: ProgramName; storageBlockIndex: UInt32; storageBlockBinding: UInt32) :=
z_ShaderStorageBlockBinding_ovr_0(&program, storageBlockIndex, storageBlockBinding);
// added in gl4.6
private z_SpecializeShader_adr := GetFuncAdr('glSpecializeShader');
private z_SpecializeShader_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32)>(z_SpecializeShader_adr);
private z_SpecializeShader_ovr_0_anh000010 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32)>(z_SpecializeShader_adr);
private z_SpecializeShader_ovr_0_anh000001 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
private z_SpecializeShader_ovr_0_anh000011 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], IntPtr.Zero) else
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000011(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private z_SpecializeShader_ovr_1_anh000010 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32)>(z_SpecializeShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShader_ovr_0_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private z_SpecializeShader_ovr_2 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
private z_SpecializeShader_ovr_2_anh000010 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShader_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShader_ovr_2_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShader_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private z_SpecializeShader_ovr_6 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32)>(z_SpecializeShader_adr);
private z_SpecializeShader_ovr_6_anh000001 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShader_ovr_6_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShader_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private z_SpecializeShader_ovr_8 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr)>(z_SpecializeShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShader_ovr_8(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: array of UInt32) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], IntPtr.Zero) else
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000011(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShader_ovr_0_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShader_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShader_ovr_2_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32) :=
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShader_ovr_0_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32) :=
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr) :=
z_SpecializeShader_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32) :=
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShader_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShader_ovr_6_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32) :=
z_SpecializeShader_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr) :=
z_SpecializeShader_ovr_8(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
// added in gl1.0
private static procedure z_StencilFunc_ovr_0(func: StencilFunction; ref: Int32; mask: UInt32);
external 'opengl32.dll' name 'glStencilFunc';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFunc(func: StencilFunction; ref: Int32; mask: UInt32) :=
z_StencilFunc_ovr_0(func, ref, mask);
// added in gl2.0
private z_StencilFuncSeparate_adr := GetFuncAdr('glStencilFuncSeparate');
private z_StencilFuncSeparate_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; func: StencilFunction; ref: Int32; mask: UInt32)>(z_StencilFuncSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFuncSeparate(face: StencilFaceDirection; func: StencilFunction; ref: Int32; mask: UInt32) :=
z_StencilFuncSeparate_ovr_0(face, func, ref, mask);
// added in gl1.0
private static procedure z_StencilMask_ovr_0(mask: UInt32);
external 'opengl32.dll' name 'glStencilMask';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilMask(mask: UInt32) :=
z_StencilMask_ovr_0(mask);
// added in gl2.0
private z_StencilMaskSeparate_adr := GetFuncAdr('glStencilMaskSeparate');
private z_StencilMaskSeparate_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; mask: UInt32)>(z_StencilMaskSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilMaskSeparate(face: StencilFaceDirection; mask: UInt32) :=
z_StencilMaskSeparate_ovr_0(face, mask);
// added in gl1.0
private static procedure z_StencilOp_ovr_0(fail: OpenGL.StencilOp; zfail: OpenGL.StencilOp; zpass: OpenGL.StencilOp);
external 'opengl32.dll' name 'glStencilOp';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOp(fail: OpenGL.StencilOp; zfail: OpenGL.StencilOp; zpass: OpenGL.StencilOp) :=
z_StencilOp_ovr_0(fail, zfail, zpass);
// added in gl2.0
private z_StencilOpSeparate_adr := GetFuncAdr('glStencilOpSeparate');
private z_StencilOpSeparate_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; sfail: OpenGL.StencilOp; dpfail: OpenGL.StencilOp; dppass: OpenGL.StencilOp)>(z_StencilOpSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOpSeparate(face: StencilFaceDirection; sfail: OpenGL.StencilOp; dpfail: OpenGL.StencilOp; dppass: OpenGL.StencilOp) :=
z_StencilOpSeparate_ovr_0(face, sfail, dpfail, dppass);
// added in gl3.1
private z_TexBuffer_adr := GetFuncAdr('glTexBuffer');
private z_TexBuffer_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName)>(z_TexBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBuffer(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName) :=
z_TexBuffer_ovr_0(target, _internalformat, buffer);
// added in gl4.3
private z_TexBufferRange_adr := GetFuncAdr('glTexBufferRange');
private z_TexBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr)>(z_TexBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferRange(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TexBufferRange_ovr_0(target, _internalformat, buffer, offset, size);
// added in gl3.3
private z_TexCoordP1ui_adr := GetFuncAdr('glTexCoordP1ui');
private z_TexCoordP1ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP1ui_ovr_0(&type, coords);
// added in gl3.3
private z_TexCoordP1uiv_adr := GetFuncAdr('glTexCoordP1uiv');
private z_TexCoordP1uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP1uiv_adr);
private z_TexCoordP1uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP1uiv_ovr_0(&type, coords[0]) else
z_TexCoordP1uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP1uiv_ovr_0(&type, coords);
private z_TexCoordP1uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP1uiv_ovr_2(&type, coords);
// added in gl3.3
private z_TexCoordP2ui_adr := GetFuncAdr('glTexCoordP2ui');
private z_TexCoordP2ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP2ui_ovr_0(&type, coords);
// added in gl3.3
private z_TexCoordP2uiv_adr := GetFuncAdr('glTexCoordP2uiv');
private z_TexCoordP2uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP2uiv_adr);
private z_TexCoordP2uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP2uiv_ovr_0(&type, coords[0]) else
z_TexCoordP2uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP2uiv_ovr_0(&type, coords);
private z_TexCoordP2uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP2uiv_ovr_2(&type, coords);
// added in gl3.3
private z_TexCoordP3ui_adr := GetFuncAdr('glTexCoordP3ui');
private z_TexCoordP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP3ui_ovr_0(&type, coords);
// added in gl3.3
private z_TexCoordP3uiv_adr := GetFuncAdr('glTexCoordP3uiv');
private z_TexCoordP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP3uiv_adr);
private z_TexCoordP3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP3uiv_ovr_0(&type, coords[0]) else
z_TexCoordP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP3uiv_ovr_0(&type, coords);
private z_TexCoordP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP3uiv_ovr_2(&type, coords);
// added in gl3.3
private z_TexCoordP4ui_adr := GetFuncAdr('glTexCoordP4ui');
private z_TexCoordP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP4ui_ovr_0(&type, coords);
// added in gl3.3
private z_TexCoordP4uiv_adr := GetFuncAdr('glTexCoordP4uiv');
private z_TexCoordP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP4uiv_adr);
private z_TexCoordP4uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP4uiv_ovr_0(&type, coords[0]) else
z_TexCoordP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP4uiv_ovr_0(&type, coords);
private z_TexCoordP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP4uiv_ovr_2(&type, coords);
// added in gl1.0
private static procedure z_TexImage1D_ovr_0(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage1D(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexImage1D_ovr_0(target, level, internalformat, width, border, format, &type, pixels);
// added in gl1.0
private static procedure z_TexImage2D_ovr_0(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage2D(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexImage2D_ovr_0(target, level, internalformat, width, height, border, format, &type, pixels);
// added in gl3.2
private z_TexImage2DMultisample_adr := GetFuncAdr('glTexImage2DMultisample');
private z_TexImage2DMultisample_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean)>(z_TexImage2DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage2DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TexImage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
// added in gl1.2
private z_TexImage3D_adr := GetFuncAdr('glTexImage3D');
private z_TexImage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3D(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexImage3D_ovr_0(target, level, internalformat, width, height, depth, border, format, &type, pixels);
// added in gl3.2
private z_TexImage3DMultisample_adr := GetFuncAdr('glTexImage3DMultisample');
private z_TexImage3DMultisample_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean)>(z_TexImage3DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TexImage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
// added in gl1.0
private static procedure z_TexParameterf_ovr_0(target: TextureTarget; pname: TextureParameterName; param: single);
external 'opengl32.dll' name 'glTexParameterf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterf(target: TextureTarget; pname: TextureParameterName; param: single) :=
z_TexParameterf_ovr_0(target, pname, param);
// added in gl1.0
private static procedure z_TexParameterfv_ovr_0(target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glTexParameterfv';
private static procedure z_TexParameterfv_ovr_0_anh0001(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; var ¶ms: single) :=
z_TexParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_TexParameterfv_ovr_2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameterfv_ovr_2(target, pname, ¶ms);
// added in gl1.0
private static procedure z_TexParameteri_ovr_0(target: TextureTarget; pname: TextureParameterName; param: Int32);
external 'opengl32.dll' name 'glTexParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteri(target: TextureTarget; pname: TextureParameterName; param: Int32) :=
z_TexParameteri_ovr_0(target, pname, param);
// added in gl3.0
private z_TexParameterIiv_adr := GetFuncAdr('glTexParameterIiv');
private z_TexParameterIiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_TexParameterIiv_adr);
private z_TexParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIiv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterIiv_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterIiv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIiv(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_TexParameterIiv_ovr_0(target, pname, ¶ms);
private z_TexParameterIiv_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIiv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameterIiv_ovr_2(target, pname, ¶ms);
// added in gl3.0
private z_TexParameterIuiv_adr := GetFuncAdr('glTexParameterIuiv');
private z_TexParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32)>(z_TexParameterIuiv_adr);
private z_TexParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuiv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterIuiv_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterIuiv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuiv(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32) :=
z_TexParameterIuiv_ovr_0(target, pname, ¶ms);
private z_TexParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuiv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameterIuiv_ovr_2(target, pname, ¶ms);
// added in gl1.0
private static procedure z_TexParameteriv_ovr_0(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexParameteriv';
private static procedure z_TexParameteriv_ovr_0_anh0001(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_TexParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_TexParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_TexParameteriv_ovr_2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameteriv_ovr_2(target, pname, ¶ms);
// added in gl4.2
private z_TexStorage1D_adr := GetFuncAdr('glTexStorage1D');
private z_TexStorage1D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32)>(z_TexStorage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage1D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32) :=
z_TexStorage1D_ovr_0(target, levels, _internalformat, width);
// added in gl4.2
private z_TexStorage2D_adr := GetFuncAdr('glTexStorage2D');
private z_TexStorage2D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_TexStorage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage2D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_TexStorage2D_ovr_0(target, levels, _internalformat, width, height);
// added in gl4.3
private z_TexStorage2DMultisample_adr := GetFuncAdr('glTexStorage2DMultisample');
private z_TexStorage2DMultisample_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean)>(z_TexStorage2DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage2DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TexStorage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
// added in gl4.2
private z_TexStorage3D_adr := GetFuncAdr('glTexStorage3D');
private z_TexStorage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32)>(z_TexStorage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage3D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32) :=
z_TexStorage3D_ovr_0(target, levels, _internalformat, width, height, depth);
// added in gl4.3
private z_TexStorage3DMultisample_adr := GetFuncAdr('glTexStorage3DMultisample');
private z_TexStorage3DMultisample_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean)>(z_TexStorage3DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage3DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TexStorage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
// added in gl1.1
private static procedure z_TexSubImage1D_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage1D(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage1D_ovr_0(target, level, xoffset, width, format, &type, pixels);
// added in gl1.1
private static procedure z_TexSubImage2D_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage2D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage2D_ovr_0(target, level, xoffset, yoffset, width, height, format, &type, pixels);
// added in gl1.2
private z_TexSubImage3D_adr := GetFuncAdr('glTexSubImage3D');
private z_TexSubImage3D_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage3D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
// added in gl4.5
private z_TextureBarrier_adr := GetFuncAdr('glTextureBarrier');
private z_TextureBarrier_ovr_0 := GetFuncOrNil&<procedure>(z_TextureBarrier_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBarrier :=
z_TextureBarrier_ovr_0;
// added in gl4.5
private z_TextureBuffer_adr := GetFuncAdr('glTextureBuffer');
private z_TextureBuffer_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName)>(z_TextureBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBuffer(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName) :=
z_TextureBuffer_ovr_0(texture, _internalformat, buffer);
// added in gl4.5
private z_TextureBufferRange_adr := GetFuncAdr('glTextureBufferRange');
private z_TextureBufferRange_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr)>(z_TextureBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferRange(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TextureBufferRange_ovr_0(texture, _internalformat, buffer, offset, size);
// added in gl4.5
private z_TextureParameterf_adr := GetFuncAdr('glTextureParameterf');
private z_TextureParameterf_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; pname: TextureParameterName; param: single)>(z_TextureParameterf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterf(texture: TextureName; pname: TextureParameterName; param: single) :=
z_TextureParameterf_ovr_0(texture, pname, param);
// added in gl4.5
private z_TextureParameterfv_adr := GetFuncAdr('glTextureParameterfv');
private z_TextureParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var param: single)>(z_TextureParameterfv_adr);
private z_TextureParameterfv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; param: IntPtr)>(z_TextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_TextureParameterfv_ovr_0(texture, pname, param[0]) else
z_TextureParameterfv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; var param: single) :=
z_TextureParameterfv_ovr_0(texture, pname, param);
private z_TextureParameterfv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; param: IntPtr)>(z_TextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; param: IntPtr) :=
z_TextureParameterfv_ovr_2(texture, pname, param);
// added in gl4.5
private z_TextureParameteri_adr := GetFuncAdr('glTextureParameteri');
private z_TextureParameteri_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; param: Int32)>(z_TextureParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteri(texture: UInt32; pname: TextureParameterName; param: Int32) :=
z_TextureParameteri_ovr_0(texture, pname, param);
// added in gl4.5
private z_TextureParameterIiv_adr := GetFuncAdr('glTextureParameterIiv');
private z_TextureParameterIiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32)>(z_TextureParameterIiv_adr);
private z_TextureParameterIiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms[0]) else
z_TextureParameterIiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32) :=
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms);
private z_TextureParameterIiv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIiv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_TextureParameterIuiv_adr := GetFuncAdr('glTextureParameterIuiv');
private z_TextureParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32)>(z_TextureParameterIuiv_adr);
private z_TextureParameterIuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]) else
z_TextureParameterIuiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32) :=
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms);
private z_TextureParameterIuiv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIuiv_ovr_2(texture, pname, ¶ms);
// added in gl4.5
private z_TextureParameteriv_adr := GetFuncAdr('glTextureParameteriv');
private z_TextureParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var param: Int32)>(z_TextureParameteriv_adr);
private z_TextureParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; param: IntPtr)>(z_TextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_TextureParameteriv_ovr_0(texture, pname, param[0]) else
z_TextureParameteriv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; var param: Int32) :=
z_TextureParameteriv_ovr_0(texture, pname, param);
private z_TextureParameteriv_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; param: IntPtr)>(z_TextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; param: IntPtr) :=
z_TextureParameteriv_ovr_2(texture, pname, param);
// added in gl4.5
private z_TextureStorage1D_adr := GetFuncAdr('glTextureStorage1D');
private z_TextureStorage1D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32)>(z_TextureStorage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage1D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32) :=
z_TextureStorage1D_ovr_0(texture, levels, _internalformat, width);
// added in gl4.5
private z_TextureStorage2D_adr := GetFuncAdr('glTextureStorage2D');
private z_TextureStorage2D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_TextureStorage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_TextureStorage2D_ovr_0(texture, levels, _internalformat, width, height);
// added in gl4.5
private z_TextureStorage2DMultisample_adr := GetFuncAdr('glTextureStorage2DMultisample');
private z_TextureStorage2DMultisample_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean)>(z_TextureStorage2DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DMultisample(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage2DMultisample_ovr_0(texture, samples, _internalformat, width, height, fixedsamplelocations);
// added in gl4.5
private z_TextureStorage3D_adr := GetFuncAdr('glTextureStorage3D');
private z_TextureStorage3D_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32)>(z_TextureStorage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32) :=
z_TextureStorage3D_ovr_0(texture, levels, _internalformat, width, height, depth);
// added in gl4.5
private z_TextureStorage3DMultisample_adr := GetFuncAdr('glTextureStorage3DMultisample');
private z_TextureStorage3DMultisample_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean)>(z_TextureStorage3DMultisample_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DMultisample(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage3DMultisample_ovr_0(texture, samples, _internalformat, width, height, depth, fixedsamplelocations);
// added in gl4.5
private z_TextureSubImage1D_adr := GetFuncAdr('glTextureSubImage1D');
private z_TextureSubImage1D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureSubImage1D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage1D(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage1D_ovr_0(texture, level, xoffset, width, format, &type, pixels);
// added in gl4.5
private z_TextureSubImage2D_adr := GetFuncAdr('glTextureSubImage2D');
private z_TextureSubImage2D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureSubImage2D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage2D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, &type, pixels);
// added in gl4.5
private z_TextureSubImage3D_adr := GetFuncAdr('glTextureSubImage3D');
private z_TextureSubImage3D_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureSubImage3D_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage3D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
// added in gl4.3
private z_TextureView_adr := GetFuncAdr('glTextureView');
private z_TextureView_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; target: TextureTarget; origtexture: TextureName; _internalformat: InternalFormat; minlevel: UInt32; numlevels: UInt32; minlayer: UInt32; numlayers: UInt32)>(z_TextureView_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureView(texture: TextureName; target: TextureTarget; origtexture: TextureName; _internalformat: InternalFormat; minlevel: UInt32; numlevels: UInt32; minlayer: UInt32; numlayers: UInt32) :=
z_TextureView_ovr_0(texture, target, origtexture, _internalformat, minlevel, numlevels, minlayer, numlayers);
// added in gl4.5
private z_TransformFeedbackBufferBase_adr := GetFuncAdr('glTransformFeedbackBufferBase');
private z_TransformFeedbackBufferBase_ovr_0 := GetFuncOrNil&<procedure(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName)>(z_TransformFeedbackBufferBase_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackBufferBase(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName) :=
z_TransformFeedbackBufferBase_ovr_0(xfb, index, buffer);
// added in gl4.5
private z_TransformFeedbackBufferRange_adr := GetFuncAdr('glTransformFeedbackBufferRange');
private z_TransformFeedbackBufferRange_ovr_0 := GetFuncOrNil&<procedure(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr)>(z_TransformFeedbackBufferRange_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackBufferRange(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TransformFeedbackBufferRange_ovr_0(xfb, index, buffer, offset, size);
// added in gl3.0
private z_TransformFeedbackVaryings_adr := GetFuncAdr('glTransformFeedbackVaryings');
private z_TransformFeedbackVaryings_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; var varyings: IntPtr; bufferMode: TransformFeedbackBufferMode)>(z_TransformFeedbackVaryings_adr);
private z_TransformFeedbackVaryings_ovr_0_anh00010 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: TransformFeedbackBufferMode)>(z_TransformFeedbackVaryings_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryings(&program: UInt32; count: Int32; varyings: array of string; bufferMode: TransformFeedbackBufferMode);
begin
var par_3_str_ptr := varyings?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_TransformFeedbackVaryings_ovr_0(&program, count, par_3_str_ptr[0], bufferMode) else
z_TransformFeedbackVaryings_ovr_0_anh00010(&program, count, IntPtr.Zero, bufferMode);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private z_TransformFeedbackVaryings_ovr_1_anh00010 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: TransformFeedbackBufferMode)>(z_TransformFeedbackVaryings_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryings(&program: UInt32; count: Int32; varyings: array of IntPtr; bufferMode: TransformFeedbackBufferMode) :=
if (varyings<>nil) and (varyings.Length<>0) then
z_TransformFeedbackVaryings_ovr_0(&program, count, varyings[0], bufferMode) else
z_TransformFeedbackVaryings_ovr_0_anh00010(&program, count, IntPtr.Zero, bufferMode);
private z_TransformFeedbackVaryings_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: TransformFeedbackBufferMode)>(z_TransformFeedbackVaryings_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryings(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: TransformFeedbackBufferMode) :=
z_TransformFeedbackVaryings_ovr_2(&program, count, varyings, bufferMode);
// added in gl4.0
private z_Uniform1d_adr := GetFuncAdr('glUniform1d');
private z_Uniform1d_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: real)>(z_Uniform1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1d(location: Int32; x: real) :=
z_Uniform1d_ovr_0(location, x);
// added in gl4.0
private z_Uniform1dv_adr := GetFuncAdr('glUniform1dv');
private z_Uniform1dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform1dv_adr);
private z_Uniform1dv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1dv_ovr_0(location, count, value[0]) else
z_Uniform1dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: real) :=
z_Uniform1dv_ovr_0(location, count, value);
private z_Uniform1dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1dv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform1f_adr := GetFuncAdr('glUniform1f');
private z_Uniform1f_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single)>(z_Uniform1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1f(location: Int32; v0: single) :=
z_Uniform1f_ovr_0(location, v0);
// added in gl2.0
private z_Uniform1fv_adr := GetFuncAdr('glUniform1fv');
private z_Uniform1fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform1fv_adr);
private z_Uniform1fv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1fv_ovr_0(location, count, value[0]) else
z_Uniform1fv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; var value: single) :=
z_Uniform1fv_ovr_0(location, count, value);
private z_Uniform1fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1fv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform1i_adr := GetFuncAdr('glUniform1i');
private z_Uniform1i_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32)>(z_Uniform1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i(location: Int32; v0: Int32) :=
z_Uniform1i_ovr_0(location, v0);
// added in gl2.0
private z_Uniform1iv_adr := GetFuncAdr('glUniform1iv');
private z_Uniform1iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform1iv_adr);
private z_Uniform1iv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1iv_ovr_0(location, count, value[0]) else
z_Uniform1iv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; var value: Int32) :=
z_Uniform1iv_ovr_0(location, count, value);
private z_Uniform1iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1iv_ovr_2(location, count, value);
// added in gl3.0
private z_Uniform1ui_adr := GetFuncAdr('glUniform1ui');
private z_Uniform1ui_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32)>(z_Uniform1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui(location: Int32; v0: UInt32) :=
z_Uniform1ui_ovr_0(location, v0);
// added in gl3.0
private z_Uniform1uiv_adr := GetFuncAdr('glUniform1uiv');
private z_Uniform1uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform1uiv_adr);
private z_Uniform1uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1uiv_ovr_0(location, count, value[0]) else
z_Uniform1uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform1uiv_ovr_0(location, count, value);
private z_Uniform1uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1uiv_ovr_2(location, count, value);
// added in gl4.0
private z_Uniform2d_adr := GetFuncAdr('glUniform2d');
private z_Uniform2d_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: real; y: real)>(z_Uniform2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2d(location: Int32; x: real; y: real) :=
z_Uniform2d_ovr_0(location, x, y);
// added in gl4.0
private z_Uniform2dv_adr := GetFuncAdr('glUniform2dv');
private z_Uniform2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform2dv_adr);
private z_Uniform2dv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2dv_ovr_0(location, count, value[0]) else
z_Uniform2dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: real) :=
z_Uniform2dv_ovr_0(location, count, value);
private z_Uniform2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2dv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform2f_adr := GetFuncAdr('glUniform2f');
private z_Uniform2f_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single)>(z_Uniform2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2f(location: Int32; v0: single; v1: single) :=
z_Uniform2f_ovr_0(location, v0, v1);
// added in gl2.0
private z_Uniform2fv_adr := GetFuncAdr('glUniform2fv');
private z_Uniform2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform2fv_adr);
private z_Uniform2fv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2fv_ovr_0(location, count, value[0]) else
z_Uniform2fv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; var value: single) :=
z_Uniform2fv_ovr_0(location, count, value);
private z_Uniform2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2fv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform2i_adr := GetFuncAdr('glUniform2i');
private z_Uniform2i_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32)>(z_Uniform2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i(location: Int32; v0: Int32; v1: Int32) :=
z_Uniform2i_ovr_0(location, v0, v1);
// added in gl2.0
private z_Uniform2iv_adr := GetFuncAdr('glUniform2iv');
private z_Uniform2iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform2iv_adr);
private z_Uniform2iv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2iv_ovr_0(location, count, value[0]) else
z_Uniform2iv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; var value: Int32) :=
z_Uniform2iv_ovr_0(location, count, value);
private z_Uniform2iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2iv_ovr_2(location, count, value);
// added in gl3.0
private z_Uniform2ui_adr := GetFuncAdr('glUniform2ui');
private z_Uniform2ui_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32)>(z_Uniform2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui(location: Int32; v0: UInt32; v1: UInt32) :=
z_Uniform2ui_ovr_0(location, v0, v1);
// added in gl3.0
private z_Uniform2uiv_adr := GetFuncAdr('glUniform2uiv');
private z_Uniform2uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform2uiv_adr);
private z_Uniform2uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2uiv_ovr_0(location, count, value[0]) else
z_Uniform2uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform2uiv_ovr_0(location, count, value);
private z_Uniform2uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2uiv_ovr_2(location, count, value);
// added in gl4.0
private z_Uniform3d_adr := GetFuncAdr('glUniform3d');
private z_Uniform3d_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: real; y: real; z: real)>(z_Uniform3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3d(location: Int32; x: real; y: real; z: real) :=
z_Uniform3d_ovr_0(location, x, y, z);
// added in gl4.0
private z_Uniform3dv_adr := GetFuncAdr('glUniform3dv');
private z_Uniform3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform3dv_adr);
private z_Uniform3dv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3dv_ovr_0(location, count, value[0]) else
z_Uniform3dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: real) :=
z_Uniform3dv_ovr_0(location, count, value);
private z_Uniform3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3dv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform3f_adr := GetFuncAdr('glUniform3f');
private z_Uniform3f_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single; v2: single)>(z_Uniform3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3f(location: Int32; v0: single; v1: single; v2: single) :=
z_Uniform3f_ovr_0(location, v0, v1, v2);
// added in gl2.0
private z_Uniform3fv_adr := GetFuncAdr('glUniform3fv');
private z_Uniform3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform3fv_adr);
private z_Uniform3fv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3fv_ovr_0(location, count, value[0]) else
z_Uniform3fv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; var value: single) :=
z_Uniform3fv_ovr_0(location, count, value);
private z_Uniform3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3fv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform3i_adr := GetFuncAdr('glUniform3i');
private z_Uniform3i_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32; v2: Int32)>(z_Uniform3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i(location: Int32; v0: Int32; v1: Int32; v2: Int32) :=
z_Uniform3i_ovr_0(location, v0, v1, v2);
// added in gl2.0
private z_Uniform3iv_adr := GetFuncAdr('glUniform3iv');
private z_Uniform3iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform3iv_adr);
private z_Uniform3iv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3iv_ovr_0(location, count, value[0]) else
z_Uniform3iv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; var value: Int32) :=
z_Uniform3iv_ovr_0(location, count, value);
private z_Uniform3iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3iv_ovr_2(location, count, value);
// added in gl3.0
private z_Uniform3ui_adr := GetFuncAdr('glUniform3ui');
private z_Uniform3ui_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32)>(z_Uniform3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32) :=
z_Uniform3ui_ovr_0(location, v0, v1, v2);
// added in gl3.0
private z_Uniform3uiv_adr := GetFuncAdr('glUniform3uiv');
private z_Uniform3uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform3uiv_adr);
private z_Uniform3uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3uiv_ovr_0(location, count, value[0]) else
z_Uniform3uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform3uiv_ovr_0(location, count, value);
private z_Uniform3uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3uiv_ovr_2(location, count, value);
// added in gl4.0
private z_Uniform4d_adr := GetFuncAdr('glUniform4d');
private z_Uniform4d_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: real; y: real; z: real; w: real)>(z_Uniform4d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4d(location: Int32; x: real; y: real; z: real; w: real) :=
z_Uniform4d_ovr_0(location, x, y, z, w);
// added in gl4.0
private z_Uniform4dv_adr := GetFuncAdr('glUniform4dv');
private z_Uniform4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform4dv_adr);
private z_Uniform4dv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4dv_ovr_0(location, count, value[0]) else
z_Uniform4dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: real) :=
z_Uniform4dv_ovr_0(location, count, value);
private z_Uniform4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4dv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform4f_adr := GetFuncAdr('glUniform4f');
private z_Uniform4f_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single; v2: single; v3: single)>(z_Uniform4f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4f(location: Int32; v0: single; v1: single; v2: single; v3: single) :=
z_Uniform4f_ovr_0(location, v0, v1, v2, v3);
// added in gl2.0
private z_Uniform4fv_adr := GetFuncAdr('glUniform4fv');
private z_Uniform4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform4fv_adr);
private z_Uniform4fv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4fv_ovr_0(location, count, value[0]) else
z_Uniform4fv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; var value: single) :=
z_Uniform4fv_ovr_0(location, count, value);
private z_Uniform4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4fv_ovr_2(location, count, value);
// added in gl2.0
private z_Uniform4i_adr := GetFuncAdr('glUniform4i');
private z_Uniform4i_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32)>(z_Uniform4i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32) :=
z_Uniform4i_ovr_0(location, v0, v1, v2, v3);
// added in gl2.0
private z_Uniform4iv_adr := GetFuncAdr('glUniform4iv');
private z_Uniform4iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform4iv_adr);
private z_Uniform4iv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4iv_ovr_0(location, count, value[0]) else
z_Uniform4iv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; var value: Int32) :=
z_Uniform4iv_ovr_0(location, count, value);
private z_Uniform4iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4iv_ovr_2(location, count, value);
// added in gl3.0
private z_Uniform4ui_adr := GetFuncAdr('glUniform4ui');
private z_Uniform4ui_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32)>(z_Uniform4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32) :=
z_Uniform4ui_ovr_0(location, v0, v1, v2, v3);
// added in gl3.0
private z_Uniform4uiv_adr := GetFuncAdr('glUniform4uiv');
private z_Uniform4uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform4uiv_adr);
private z_Uniform4uiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4uiv_ovr_0(location, count, value[0]) else
z_Uniform4uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform4uiv_ovr_0(location, count, value);
private z_Uniform4uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4uiv_ovr_2(location, count, value);
// added in gl3.1
private z_UniformBlockBinding_adr := GetFuncAdr('glUniformBlockBinding');
private z_UniformBlockBinding_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; uniformBlockIndex: UInt32; uniformBlockBinding: UInt32)>(z_UniformBlockBinding_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformBlockBinding(&program: ProgramName; uniformBlockIndex: UInt32; uniformBlockBinding: UInt32) :=
z_UniformBlockBinding_ovr_0(&program, uniformBlockIndex, uniformBlockBinding);
// added in gl4.0
private z_UniformMatrix2dv_adr := GetFuncAdr('glUniformMatrix2dv');
private z_UniformMatrix2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2dv_adr);
private z_UniformMatrix2dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2dv_ovr_2(location, count, transpose, value);
// added in gl2.0
private z_UniformMatrix2fv_adr := GetFuncAdr('glUniformMatrix2fv');
private z_UniformMatrix2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2fv_adr);
private z_UniformMatrix2fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix2fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix2x3dv_adr := GetFuncAdr('glUniformMatrix2x3dv');
private z_UniformMatrix2x3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2x3dv_adr);
private z_UniformMatrix2x3dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2x3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x3dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix2x3fv_adr := GetFuncAdr('glUniformMatrix2x3fv');
private z_UniformMatrix2x3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2x3fv_adr);
private z_UniformMatrix2x3fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x3fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x3fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix2x3fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2x3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x3fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix2x4dv_adr := GetFuncAdr('glUniformMatrix2x4dv');
private z_UniformMatrix2x4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2x4dv_adr);
private z_UniformMatrix2x4dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2x4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x4dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix2x4fv_adr := GetFuncAdr('glUniformMatrix2x4fv');
private z_UniformMatrix2x4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2x4fv_adr);
private z_UniformMatrix2x4fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x4fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x4fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix2x4fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix2x4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x4fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix3dv_adr := GetFuncAdr('glUniformMatrix3dv');
private z_UniformMatrix3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3dv_adr);
private z_UniformMatrix3dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3dv_ovr_2(location, count, transpose, value);
// added in gl2.0
private z_UniformMatrix3fv_adr := GetFuncAdr('glUniformMatrix3fv');
private z_UniformMatrix3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3fv_adr);
private z_UniformMatrix3fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix3fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix3x2dv_adr := GetFuncAdr('glUniformMatrix3x2dv');
private z_UniformMatrix3x2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3x2dv_adr);
private z_UniformMatrix3x2dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3x2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x2dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix3x2fv_adr := GetFuncAdr('glUniformMatrix3x2fv');
private z_UniformMatrix3x2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3x2fv_adr);
private z_UniformMatrix3x2fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x2fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x2fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix3x2fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3x2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x2fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix3x4dv_adr := GetFuncAdr('glUniformMatrix3x4dv');
private z_UniformMatrix3x4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3x4dv_adr);
private z_UniformMatrix3x4dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3x4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x4dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix3x4fv_adr := GetFuncAdr('glUniformMatrix3x4fv');
private z_UniformMatrix3x4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3x4fv_adr);
private z_UniformMatrix3x4fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x4fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x4fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix3x4fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix3x4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x4fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix4dv_adr := GetFuncAdr('glUniformMatrix4dv');
private z_UniformMatrix4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4dv_adr);
private z_UniformMatrix4dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4dv_ovr_2(location, count, transpose, value);
// added in gl2.0
private z_UniformMatrix4fv_adr := GetFuncAdr('glUniformMatrix4fv');
private z_UniformMatrix4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4fv_adr);
private z_UniformMatrix4fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix4fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix4x2dv_adr := GetFuncAdr('glUniformMatrix4x2dv');
private z_UniformMatrix4x2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4x2dv_adr);
private z_UniformMatrix4x2dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4x2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x2dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix4x2fv_adr := GetFuncAdr('glUniformMatrix4x2fv');
private z_UniformMatrix4x2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4x2fv_adr);
private z_UniformMatrix4x2fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x2fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x2fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix4x2fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4x2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x2fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformMatrix4x3dv_adr := GetFuncAdr('glUniformMatrix4x3dv');
private z_UniformMatrix4x3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4x3dv_adr);
private z_UniformMatrix4x3dv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4x3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x3dv_ovr_2(location, count, transpose, value);
// added in gl2.1
private z_UniformMatrix4x3fv_adr := GetFuncAdr('glUniformMatrix4x3fv');
private z_UniformMatrix4x3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4x3fv_adr);
private z_UniformMatrix4x3fv_ovr_0_anh00001 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3fv(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x3fv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x3fv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3fv(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix4x3fv_ovr_0(location, count, transpose, value);
private z_UniformMatrix4x3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3fv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x3fv_ovr_2(location, count, transpose, value);
// added in gl4.0
private z_UniformSubroutinesuiv_adr := GetFuncAdr('glUniformSubroutinesuiv');
private z_UniformSubroutinesuiv_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; count: Int32; var indices: UInt32)>(z_UniformSubroutinesuiv_adr);
private z_UniformSubroutinesuiv_ovr_0_anh0001 := GetFuncOrNil&<procedure(_shadertype: ShaderType; count: Int32; indices: IntPtr)>(z_UniformSubroutinesuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; indices: array of UInt32) :=
if (indices<>nil) and (indices.Length<>0) then
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices[0]) else
z_UniformSubroutinesuiv_ovr_0_anh0001(_shadertype, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; var indices: UInt32) :=
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices);
private z_UniformSubroutinesuiv_ovr_2 := GetFuncOrNil&<procedure(_shadertype: ShaderType; count: Int32; indices: IntPtr)>(z_UniformSubroutinesuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; indices: IntPtr) :=
z_UniformSubroutinesuiv_ovr_2(_shadertype, count, indices);
// added in gl1.5
private z_UnmapBuffer_adr := GetFuncAdr('glUnmapBuffer');
private z_UnmapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB): boolean>(z_UnmapBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBuffer(target: BufferTargetARB): boolean :=
z_UnmapBuffer_ovr_0(target);
// added in gl4.5
private z_UnmapNamedBuffer_adr := GetFuncAdr('glUnmapNamedBuffer');
private z_UnmapNamedBuffer_ovr_0 := GetFuncOrNil&<function(buffer: BufferName): boolean>(z_UnmapNamedBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapNamedBuffer(buffer: BufferName): boolean :=
z_UnmapNamedBuffer_ovr_0(buffer);
// added in gl2.0
private z_UseProgram_adr := GetFuncAdr('glUseProgram');
private z_UseProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_UseProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgram(&program: ProgramName) :=
z_UseProgram_ovr_0(&program);
// added in gl4.1
private z_UseProgramStages_adr := GetFuncAdr('glUseProgramStages');
private z_UseProgramStages_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName; stages: UseProgramStageMask; &program: ProgramName)>(z_UseProgramStages_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgramStages(pipeline: ProgramPipelineName; stages: UseProgramStageMask; &program: ProgramName) :=
z_UseProgramStages_ovr_0(pipeline, stages, &program);
// added in gl2.0
private z_ValidateProgram_adr := GetFuncAdr('glValidateProgram');
private z_ValidateProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_ValidateProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgram(&program: ProgramName) :=
z_ValidateProgram_ovr_0(&program);
// added in gl4.1
private z_ValidateProgramPipeline_adr := GetFuncAdr('glValidateProgramPipeline');
private z_ValidateProgramPipeline_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName)>(z_ValidateProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgramPipeline(pipeline: ProgramPipelineName) :=
z_ValidateProgramPipeline_ovr_0(pipeline);
// added in gl4.5
private z_VertexArrayAttribBinding_adr := GetFuncAdr('glVertexArrayAttribBinding');
private z_VertexArrayAttribBinding_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; attribindex: UInt32; bindingindex: UInt32)>(z_VertexArrayAttribBinding_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribBinding(vaobj: VertexArrayName; attribindex: UInt32; bindingindex: UInt32) :=
z_VertexArrayAttribBinding_ovr_0(vaobj, attribindex, bindingindex);
// added in gl4.5
private z_VertexArrayAttribFormat_adr := GetFuncAdr('glVertexArrayAttribFormat');
private z_VertexArrayAttribFormat_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32)>(z_VertexArrayAttribFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32) :=
z_VertexArrayAttribFormat_ovr_0(vaobj, attribindex, size, &type, normalized, relativeoffset);
// added in gl4.5
private z_VertexArrayAttribIFormat_adr := GetFuncAdr('glVertexArrayAttribIFormat');
private z_VertexArrayAttribIFormat_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32)>(z_VertexArrayAttribIFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribIFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32) :=
z_VertexArrayAttribIFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
// added in gl4.5
private z_VertexArrayAttribLFormat_adr := GetFuncAdr('glVertexArrayAttribLFormat');
private z_VertexArrayAttribLFormat_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32)>(z_VertexArrayAttribLFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribLFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32) :=
z_VertexArrayAttribLFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
// added in gl4.5
private z_VertexArrayBindingDivisor_adr := GetFuncAdr('glVertexArrayBindingDivisor');
private z_VertexArrayBindingDivisor_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; bindingindex: UInt32; divisor: UInt32)>(z_VertexArrayBindingDivisor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayBindingDivisor(vaobj: VertexArrayName; bindingindex: UInt32; divisor: UInt32) :=
z_VertexArrayBindingDivisor_ovr_0(vaobj, bindingindex, divisor);
// added in gl4.5
private z_VertexArrayElementBuffer_adr := GetFuncAdr('glVertexArrayElementBuffer');
private z_VertexArrayElementBuffer_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; buffer: BufferName)>(z_VertexArrayElementBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayElementBuffer(vaobj: VertexArrayName; buffer: BufferName) :=
z_VertexArrayElementBuffer_ovr_0(vaobj, buffer);
// added in gl4.5
private z_VertexArrayVertexBuffer_adr := GetFuncAdr('glVertexArrayVertexBuffer');
private z_VertexArrayVertexBuffer_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32)>(z_VertexArrayVertexBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffer(vaobj: VertexArrayName; bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32) :=
z_VertexArrayVertexBuffer_ovr_0(vaobj, bindingindex, buffer, offset, stride);
// added in gl4.5
private z_VertexArrayVertexBuffers_adr := GetFuncAdr('glVertexArrayVertexBuffers');
private z_VertexArrayVertexBuffers_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000110 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000001 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000101 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000011 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_0_anh0000111 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000011(vaobj, first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000101(vaobj, first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000111(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private z_VertexArrayVertexBuffers_ovr_1_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_1_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_1_anh0000110 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides);
private z_VertexArrayVertexBuffers_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_2_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_2_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_2_anh0000110 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides);
private z_VertexArrayVertexBuffers_ovr_3_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_3_anh0000101 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000101(vaobj, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_VertexArrayVertexBuffers_ovr_4_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_5_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_6 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_6_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_6_anh0000001 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_6_anh0000101 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000001(vaobj, first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000101(vaobj, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private z_VertexArrayVertexBuffers_ovr_7_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_6_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_8 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_8_anh0000100 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_8_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_9_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_9_anh0000011 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000011(vaobj, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_VertexArrayVertexBuffers_ovr_10_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
private z_VertexArrayVertexBuffers_ovr_11_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_18 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_18_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_18_anh0000001 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_18_anh0000011 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000001(vaobj, first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000011(vaobj, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private z_VertexArrayVertexBuffers_ovr_19_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_18_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
private z_VertexArrayVertexBuffers_ovr_20 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_20_anh0000010 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_20_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_24 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32)>(z_VertexArrayVertexBuffers_adr);
private z_VertexArrayVertexBuffers_ovr_24_anh0000001 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_24_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides);
private z_VertexArrayVertexBuffers_ovr_26 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr)>(z_VertexArrayVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_26(vaobj, first, count, buffers, offsets, strides);
// added in gl2.0
private z_VertexAttrib1d_adr := GetFuncAdr('glVertexAttrib1d');
private z_VertexAttrib1d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttrib1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1d(index: UInt32; x: real) :=
z_VertexAttrib1d_ovr_0(index, x);
// added in gl2.0
private z_VertexAttrib1dv_adr := GetFuncAdr('glVertexAttrib1dv');
private z_VertexAttrib1dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib1dv_adr);
private z_VertexAttrib1dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1dv_ovr_0(index, v[0]) else
z_VertexAttrib1dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; var v: real) :=
z_VertexAttrib1dv_ovr_0(index, v);
private z_VertexAttrib1dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; v: IntPtr) :=
z_VertexAttrib1dv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib1f_adr := GetFuncAdr('glVertexAttrib1f');
private z_VertexAttrib1f_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single)>(z_VertexAttrib1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1f(index: UInt32; x: single) :=
z_VertexAttrib1f_ovr_0(index, x);
// added in gl2.0
private z_VertexAttrib1fv_adr := GetFuncAdr('glVertexAttrib1fv');
private z_VertexAttrib1fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib1fv_adr);
private z_VertexAttrib1fv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1fv_ovr_0(index, v[0]) else
z_VertexAttrib1fv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; var v: single) :=
z_VertexAttrib1fv_ovr_0(index, v);
private z_VertexAttrib1fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; v: IntPtr) :=
z_VertexAttrib1fv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib1s_adr := GetFuncAdr('glVertexAttrib1s');
private z_VertexAttrib1s_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16)>(z_VertexAttrib1s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1s(index: UInt32; x: Int16) :=
z_VertexAttrib1s_ovr_0(index, x);
// added in gl2.0
private z_VertexAttrib1sv_adr := GetFuncAdr('glVertexAttrib1sv');
private z_VertexAttrib1sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib1sv_adr);
private z_VertexAttrib1sv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1sv_ovr_0(index, v[0]) else
z_VertexAttrib1sv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; var v: Int16) :=
z_VertexAttrib1sv_ovr_0(index, v);
private z_VertexAttrib1sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; v: IntPtr) :=
z_VertexAttrib1sv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib2d_adr := GetFuncAdr('glVertexAttrib2d');
private z_VertexAttrib2d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttrib2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2d(index: UInt32; x: real; y: real) :=
z_VertexAttrib2d_ovr_0(index, x, y);
// added in gl2.0
private z_VertexAttrib2dv_adr := GetFuncAdr('glVertexAttrib2dv');
private z_VertexAttrib2dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib2dv_adr);
private z_VertexAttrib2dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2dv_ovr_0(index, v[0]) else
z_VertexAttrib2dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; var v: real) :=
z_VertexAttrib2dv_ovr_0(index, v);
private z_VertexAttrib2dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; v: IntPtr) :=
z_VertexAttrib2dv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib2f_adr := GetFuncAdr('glVertexAttrib2f');
private z_VertexAttrib2f_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single)>(z_VertexAttrib2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2f(index: UInt32; x: single; y: single) :=
z_VertexAttrib2f_ovr_0(index, x, y);
// added in gl2.0
private z_VertexAttrib2fv_adr := GetFuncAdr('glVertexAttrib2fv');
private z_VertexAttrib2fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib2fv_adr);
private z_VertexAttrib2fv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2fv_ovr_0(index, v[0]) else
z_VertexAttrib2fv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; var v: single) :=
z_VertexAttrib2fv_ovr_0(index, v);
private z_VertexAttrib2fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; v: IntPtr) :=
z_VertexAttrib2fv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib2s_adr := GetFuncAdr('glVertexAttrib2s');
private z_VertexAttrib2s_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16)>(z_VertexAttrib2s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2s(index: UInt32; x: Int16; y: Int16) :=
z_VertexAttrib2s_ovr_0(index, x, y);
// added in gl2.0
private z_VertexAttrib2sv_adr := GetFuncAdr('glVertexAttrib2sv');
private z_VertexAttrib2sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib2sv_adr);
private z_VertexAttrib2sv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2sv_ovr_0(index, v[0]) else
z_VertexAttrib2sv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; var v: Int16) :=
z_VertexAttrib2sv_ovr_0(index, v);
private z_VertexAttrib2sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; v: IntPtr) :=
z_VertexAttrib2sv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib3d_adr := GetFuncAdr('glVertexAttrib3d');
private z_VertexAttrib3d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttrib3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3d(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttrib3d_ovr_0(index, x, y, z);
// added in gl2.0
private z_VertexAttrib3dv_adr := GetFuncAdr('glVertexAttrib3dv');
private z_VertexAttrib3dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib3dv_adr);
private z_VertexAttrib3dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3dv_ovr_0(index, v[0]) else
z_VertexAttrib3dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; var v: real) :=
z_VertexAttrib3dv_ovr_0(index, v);
private z_VertexAttrib3dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; v: IntPtr) :=
z_VertexAttrib3dv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib3f_adr := GetFuncAdr('glVertexAttrib3f');
private z_VertexAttrib3f_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single)>(z_VertexAttrib3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3f(index: UInt32; x: single; y: single; z: single) :=
z_VertexAttrib3f_ovr_0(index, x, y, z);
// added in gl2.0
private z_VertexAttrib3fv_adr := GetFuncAdr('glVertexAttrib3fv');
private z_VertexAttrib3fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib3fv_adr);
private z_VertexAttrib3fv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3fv_ovr_0(index, v[0]) else
z_VertexAttrib3fv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; var v: single) :=
z_VertexAttrib3fv_ovr_0(index, v);
private z_VertexAttrib3fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; v: IntPtr) :=
z_VertexAttrib3fv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib3s_adr := GetFuncAdr('glVertexAttrib3s');
private z_VertexAttrib3s_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16)>(z_VertexAttrib3s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3s(index: UInt32; x: Int16; y: Int16; z: Int16) :=
z_VertexAttrib3s_ovr_0(index, x, y, z);
// added in gl2.0
private z_VertexAttrib3sv_adr := GetFuncAdr('glVertexAttrib3sv');
private z_VertexAttrib3sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib3sv_adr);
private z_VertexAttrib3sv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3sv_ovr_0(index, v[0]) else
z_VertexAttrib3sv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; var v: Int16) :=
z_VertexAttrib3sv_ovr_0(index, v);
private z_VertexAttrib3sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; v: IntPtr) :=
z_VertexAttrib3sv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4bv_adr := GetFuncAdr('glVertexAttrib4bv');
private z_VertexAttrib4bv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4bv_adr);
private z_VertexAttrib4bv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4bv_ovr_0(index, v[0]) else
z_VertexAttrib4bv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; var v: SByte) :=
z_VertexAttrib4bv_ovr_0(index, v);
private z_VertexAttrib4bv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4bv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4d_adr := GetFuncAdr('glVertexAttrib4d');
private z_VertexAttrib4d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttrib4d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4d(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttrib4d_ovr_0(index, x, y, z, w);
// added in gl2.0
private z_VertexAttrib4dv_adr := GetFuncAdr('glVertexAttrib4dv');
private z_VertexAttrib4dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib4dv_adr);
private z_VertexAttrib4dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4dv_ovr_0(index, v[0]) else
z_VertexAttrib4dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; var v: real) :=
z_VertexAttrib4dv_ovr_0(index, v);
private z_VertexAttrib4dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4dv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4f_adr := GetFuncAdr('glVertexAttrib4f');
private z_VertexAttrib4f_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single; w: single)>(z_VertexAttrib4f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4f(index: UInt32; x: single; y: single; z: single; w: single) :=
z_VertexAttrib4f_ovr_0(index, x, y, z, w);
// added in gl2.0
private z_VertexAttrib4fv_adr := GetFuncAdr('glVertexAttrib4fv');
private z_VertexAttrib4fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib4fv_adr);
private z_VertexAttrib4fv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4fv_ovr_0(index, v[0]) else
z_VertexAttrib4fv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; var v: single) :=
z_VertexAttrib4fv_ovr_0(index, v);
private z_VertexAttrib4fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4fv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4iv_adr := GetFuncAdr('glVertexAttrib4iv');
private z_VertexAttrib4iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4iv_adr);
private z_VertexAttrib4iv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4iv_ovr_0(index, v[0]) else
z_VertexAttrib4iv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; var v: Int32) :=
z_VertexAttrib4iv_ovr_0(index, v);
private z_VertexAttrib4iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4iv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Nbv_adr := GetFuncAdr('glVertexAttrib4Nbv');
private z_VertexAttrib4Nbv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4Nbv_adr);
private z_VertexAttrib4Nbv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nbv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Nbv_ovr_0(index, v[0]) else
z_VertexAttrib4Nbv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; var v: SByte) :=
z_VertexAttrib4Nbv_ovr_0(index, v);
private z_VertexAttrib4Nbv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nbv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Nbv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Niv_adr := GetFuncAdr('glVertexAttrib4Niv');
private z_VertexAttrib4Niv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4Niv_adr);
private z_VertexAttrib4Niv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Niv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Niv_ovr_0(index, v[0]) else
z_VertexAttrib4Niv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; var v: Int32) :=
z_VertexAttrib4Niv_ovr_0(index, v);
private z_VertexAttrib4Niv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Niv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Niv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Nsv_adr := GetFuncAdr('glVertexAttrib4Nsv');
private z_VertexAttrib4Nsv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4Nsv_adr);
private z_VertexAttrib4Nsv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nsv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Nsv_ovr_0(index, v[0]) else
z_VertexAttrib4Nsv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; var v: Int16) :=
z_VertexAttrib4Nsv_ovr_0(index, v);
private z_VertexAttrib4Nsv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nsv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Nsv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Nub_adr := GetFuncAdr('glVertexAttrib4Nub');
private z_VertexAttrib4Nub_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte)>(z_VertexAttrib4Nub_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nub(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte) :=
z_VertexAttrib4Nub_ovr_0(index, x, y, z, w);
// added in gl2.0
private z_VertexAttrib4Nubv_adr := GetFuncAdr('glVertexAttrib4Nubv');
private z_VertexAttrib4Nubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4Nubv_adr);
private z_VertexAttrib4Nubv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Nubv_ovr_0(index, v[0]) else
z_VertexAttrib4Nubv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; var v: Byte) :=
z_VertexAttrib4Nubv_ovr_0(index, v);
private z_VertexAttrib4Nubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Nubv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Nuiv_adr := GetFuncAdr('glVertexAttrib4Nuiv');
private z_VertexAttrib4Nuiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4Nuiv_adr);
private z_VertexAttrib4Nuiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Nuiv_ovr_0(index, v[0]) else
z_VertexAttrib4Nuiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; var v: UInt32) :=
z_VertexAttrib4Nuiv_ovr_0(index, v);
private z_VertexAttrib4Nuiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Nuiv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4Nusv_adr := GetFuncAdr('glVertexAttrib4Nusv');
private z_VertexAttrib4Nusv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4Nusv_adr);
private z_VertexAttrib4Nusv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4Nusv_ovr_0(index, v[0]) else
z_VertexAttrib4Nusv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; var v: UInt16) :=
z_VertexAttrib4Nusv_ovr_0(index, v);
private z_VertexAttrib4Nusv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4Nusv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4s_adr := GetFuncAdr('glVertexAttrib4s');
private z_VertexAttrib4s_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16)>(z_VertexAttrib4s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4s(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16) :=
z_VertexAttrib4s_ovr_0(index, x, y, z, w);
// added in gl2.0
private z_VertexAttrib4sv_adr := GetFuncAdr('glVertexAttrib4sv');
private z_VertexAttrib4sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4sv_adr);
private z_VertexAttrib4sv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4sv_ovr_0(index, v[0]) else
z_VertexAttrib4sv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; var v: Int16) :=
z_VertexAttrib4sv_ovr_0(index, v);
private z_VertexAttrib4sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4sv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4ubv_adr := GetFuncAdr('glVertexAttrib4ubv');
private z_VertexAttrib4ubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4ubv_adr);
private z_VertexAttrib4ubv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ubv_ovr_0(index, v[0]) else
z_VertexAttrib4ubv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; var v: Byte) :=
z_VertexAttrib4ubv_ovr_0(index, v);
private z_VertexAttrib4ubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ubv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4uiv_adr := GetFuncAdr('glVertexAttrib4uiv');
private z_VertexAttrib4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4uiv_adr);
private z_VertexAttrib4uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4uiv_ovr_0(index, v[0]) else
z_VertexAttrib4uiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; var v: UInt32) :=
z_VertexAttrib4uiv_ovr_0(index, v);
private z_VertexAttrib4uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4uiv_ovr_2(index, v);
// added in gl2.0
private z_VertexAttrib4usv_adr := GetFuncAdr('glVertexAttrib4usv');
private z_VertexAttrib4usv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4usv_adr);
private z_VertexAttrib4usv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4usv_ovr_0(index, v[0]) else
z_VertexAttrib4usv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; var v: UInt16) :=
z_VertexAttrib4usv_ovr_0(index, v);
private z_VertexAttrib4usv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; v: IntPtr) :=
z_VertexAttrib4usv_ovr_2(index, v);
// added in gl4.3
private z_VertexAttribBinding_adr := GetFuncAdr('glVertexAttribBinding');
private z_VertexAttribBinding_ovr_0 := GetFuncOrNil&<procedure(attribindex: UInt32; bindingindex: UInt32)>(z_VertexAttribBinding_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribBinding(attribindex: UInt32; bindingindex: UInt32) :=
z_VertexAttribBinding_ovr_0(attribindex, bindingindex);
// added in gl3.3
private z_VertexAttribDivisor_adr := GetFuncAdr('glVertexAttribDivisor');
private z_VertexAttribDivisor_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; divisor: UInt32)>(z_VertexAttribDivisor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribDivisor(index: UInt32; divisor: UInt32) :=
z_VertexAttribDivisor_ovr_0(index, divisor);
// added in gl4.3
private z_VertexAttribFormat_adr := GetFuncAdr('glVertexAttribFormat');
private z_VertexAttribFormat_ovr_0 := GetFuncOrNil&<procedure(attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32)>(z_VertexAttribFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribFormat(attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32) :=
z_VertexAttribFormat_ovr_0(attribindex, size, &type, normalized, relativeoffset);
// added in gl3.0
private z_VertexAttribI1i_adr := GetFuncAdr('glVertexAttribI1i');
private z_VertexAttribI1i_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int32)>(z_VertexAttribI1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1i(index: UInt32; x: Int32) :=
z_VertexAttribI1i_ovr_0(index, x);
// added in gl3.0
private z_VertexAttribI1iv_adr := GetFuncAdr('glVertexAttribI1iv');
private z_VertexAttribI1iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI1iv_adr);
private z_VertexAttribI1iv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI1iv_ovr_0(index, v[0]) else
z_VertexAttribI1iv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; var v: Int32) :=
z_VertexAttribI1iv_ovr_0(index, v);
private z_VertexAttribI1iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; v: IntPtr) :=
z_VertexAttribI1iv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI1ui_adr := GetFuncAdr('glVertexAttribI1ui');
private z_VertexAttribI1ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt32)>(z_VertexAttribI1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1ui(index: UInt32; x: UInt32) :=
z_VertexAttribI1ui_ovr_0(index, x);
// added in gl3.0
private z_VertexAttribI1uiv_adr := GetFuncAdr('glVertexAttribI1uiv');
private z_VertexAttribI1uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI1uiv_adr);
private z_VertexAttribI1uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI1uiv_ovr_0(index, v[0]) else
z_VertexAttribI1uiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; var v: UInt32) :=
z_VertexAttribI1uiv_ovr_0(index, v);
private z_VertexAttribI1uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; v: IntPtr) :=
z_VertexAttribI1uiv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI2i_adr := GetFuncAdr('glVertexAttribI2i');
private z_VertexAttribI2i_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int32; y: Int32)>(z_VertexAttribI2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2i(index: UInt32; x: Int32; y: Int32) :=
z_VertexAttribI2i_ovr_0(index, x, y);
// added in gl3.0
private z_VertexAttribI2iv_adr := GetFuncAdr('glVertexAttribI2iv');
private z_VertexAttribI2iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI2iv_adr);
private z_VertexAttribI2iv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI2iv_ovr_0(index, v[0]) else
z_VertexAttribI2iv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; var v: Int32) :=
z_VertexAttribI2iv_ovr_0(index, v);
private z_VertexAttribI2iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; v: IntPtr) :=
z_VertexAttribI2iv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI2ui_adr := GetFuncAdr('glVertexAttribI2ui');
private z_VertexAttribI2ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt32; y: UInt32)>(z_VertexAttribI2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2ui(index: UInt32; x: UInt32; y: UInt32) :=
z_VertexAttribI2ui_ovr_0(index, x, y);
// added in gl3.0
private z_VertexAttribI2uiv_adr := GetFuncAdr('glVertexAttribI2uiv');
private z_VertexAttribI2uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI2uiv_adr);
private z_VertexAttribI2uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI2uiv_ovr_0(index, v[0]) else
z_VertexAttribI2uiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; var v: UInt32) :=
z_VertexAttribI2uiv_ovr_0(index, v);
private z_VertexAttribI2uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; v: IntPtr) :=
z_VertexAttribI2uiv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI3i_adr := GetFuncAdr('glVertexAttribI3i');
private z_VertexAttribI3i_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int32; y: Int32; z: Int32)>(z_VertexAttribI3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3i(index: UInt32; x: Int32; y: Int32; z: Int32) :=
z_VertexAttribI3i_ovr_0(index, x, y, z);
// added in gl3.0
private z_VertexAttribI3iv_adr := GetFuncAdr('glVertexAttribI3iv');
private z_VertexAttribI3iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI3iv_adr);
private z_VertexAttribI3iv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI3iv_ovr_0(index, v[0]) else
z_VertexAttribI3iv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; var v: Int32) :=
z_VertexAttribI3iv_ovr_0(index, v);
private z_VertexAttribI3iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; v: IntPtr) :=
z_VertexAttribI3iv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI3ui_adr := GetFuncAdr('glVertexAttribI3ui');
private z_VertexAttribI3ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt32; y: UInt32; z: UInt32)>(z_VertexAttribI3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3ui(index: UInt32; x: UInt32; y: UInt32; z: UInt32) :=
z_VertexAttribI3ui_ovr_0(index, x, y, z);
// added in gl3.0
private z_VertexAttribI3uiv_adr := GetFuncAdr('glVertexAttribI3uiv');
private z_VertexAttribI3uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI3uiv_adr);
private z_VertexAttribI3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI3uiv_ovr_0(index, v[0]) else
z_VertexAttribI3uiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; var v: UInt32) :=
z_VertexAttribI3uiv_ovr_0(index, v);
private z_VertexAttribI3uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; v: IntPtr) :=
z_VertexAttribI3uiv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4bv_adr := GetFuncAdr('glVertexAttribI4bv');
private z_VertexAttribI4bv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttribI4bv_adr);
private z_VertexAttribI4bv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4bv_ovr_0(index, v[0]) else
z_VertexAttribI4bv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; var v: SByte) :=
z_VertexAttribI4bv_ovr_0(index, v);
private z_VertexAttribI4bv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4bv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4i_adr := GetFuncAdr('glVertexAttribI4i');
private z_VertexAttribI4i_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32)>(z_VertexAttribI4i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4i(index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_VertexAttribI4i_ovr_0(index, x, y, z, w);
// added in gl3.0
private z_VertexAttribI4iv_adr := GetFuncAdr('glVertexAttribI4iv');
private z_VertexAttribI4iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI4iv_adr);
private z_VertexAttribI4iv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4iv_ovr_0(index, v[0]) else
z_VertexAttribI4iv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; var v: Int32) :=
z_VertexAttribI4iv_ovr_0(index, v);
private z_VertexAttribI4iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4iv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4sv_adr := GetFuncAdr('glVertexAttribI4sv');
private z_VertexAttribI4sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttribI4sv_adr);
private z_VertexAttribI4sv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4sv_ovr_0(index, v[0]) else
z_VertexAttribI4sv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; var v: Int16) :=
z_VertexAttribI4sv_ovr_0(index, v);
private z_VertexAttribI4sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4sv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4ubv_adr := GetFuncAdr('glVertexAttribI4ubv');
private z_VertexAttribI4ubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttribI4ubv_adr);
private z_VertexAttribI4ubv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4ubv_ovr_0(index, v[0]) else
z_VertexAttribI4ubv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; var v: Byte) :=
z_VertexAttribI4ubv_ovr_0(index, v);
private z_VertexAttribI4ubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4ubv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4ui_adr := GetFuncAdr('glVertexAttribI4ui');
private z_VertexAttribI4ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32)>(z_VertexAttribI4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ui(index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32) :=
z_VertexAttribI4ui_ovr_0(index, x, y, z, w);
// added in gl3.0
private z_VertexAttribI4uiv_adr := GetFuncAdr('glVertexAttribI4uiv');
private z_VertexAttribI4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI4uiv_adr);
private z_VertexAttribI4uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4uiv_ovr_0(index, v[0]) else
z_VertexAttribI4uiv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; var v: UInt32) :=
z_VertexAttribI4uiv_ovr_0(index, v);
private z_VertexAttribI4uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4uiv_ovr_2(index, v);
// added in gl3.0
private z_VertexAttribI4usv_adr := GetFuncAdr('glVertexAttribI4usv');
private z_VertexAttribI4usv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttribI4usv_adr);
private z_VertexAttribI4usv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4usv_ovr_0(index, v[0]) else
z_VertexAttribI4usv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; var v: UInt16) :=
z_VertexAttribI4usv_ovr_0(index, v);
private z_VertexAttribI4usv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; v: IntPtr) :=
z_VertexAttribI4usv_ovr_2(index, v);
// added in gl4.3
private z_VertexAttribIFormat_adr := GetFuncAdr('glVertexAttribIFormat');
private z_VertexAttribIFormat_ovr_0 := GetFuncOrNil&<procedure(attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32)>(z_VertexAttribIFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIFormat(attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32) :=
z_VertexAttribIFormat_ovr_0(attribindex, size, &type, relativeoffset);
// added in gl3.0
private z_VertexAttribIPointer_adr := GetFuncAdr('glVertexAttribIPointer');
private z_VertexAttribIPointer_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr)>(z_VertexAttribIPointer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIPointer(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexAttribIPointer_ovr_0(index, size, &type, stride, pointer);
// added in gl4.1
private z_VertexAttribL1d_adr := GetFuncAdr('glVertexAttribL1d');
private z_VertexAttribL1d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttribL1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1d(index: UInt32; x: real) :=
z_VertexAttribL1d_ovr_0(index, x);
// added in gl4.1
private z_VertexAttribL1dv_adr := GetFuncAdr('glVertexAttribL1dv');
private z_VertexAttribL1dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL1dv_adr);
private z_VertexAttribL1dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1dv_ovr_0(index, v[0]) else
z_VertexAttribL1dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; var v: real) :=
z_VertexAttribL1dv_ovr_0(index, v);
private z_VertexAttribL1dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL1dv_ovr_2(index, v);
// added in gl4.1
private z_VertexAttribL2d_adr := GetFuncAdr('glVertexAttribL2d');
private z_VertexAttribL2d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttribL2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2d(index: UInt32; x: real; y: real) :=
z_VertexAttribL2d_ovr_0(index, x, y);
// added in gl4.1
private z_VertexAttribL2dv_adr := GetFuncAdr('glVertexAttribL2dv');
private z_VertexAttribL2dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL2dv_adr);
private z_VertexAttribL2dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL2dv_ovr_0(index, v[0]) else
z_VertexAttribL2dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; var v: real) :=
z_VertexAttribL2dv_ovr_0(index, v);
private z_VertexAttribL2dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL2dv_ovr_2(index, v);
// added in gl4.1
private z_VertexAttribL3d_adr := GetFuncAdr('glVertexAttribL3d');
private z_VertexAttribL3d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttribL3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3d(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttribL3d_ovr_0(index, x, y, z);
// added in gl4.1
private z_VertexAttribL3dv_adr := GetFuncAdr('glVertexAttribL3dv');
private z_VertexAttribL3dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL3dv_adr);
private z_VertexAttribL3dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL3dv_ovr_0(index, v[0]) else
z_VertexAttribL3dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; var v: real) :=
z_VertexAttribL3dv_ovr_0(index, v);
private z_VertexAttribL3dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL3dv_ovr_2(index, v);
// added in gl4.1
private z_VertexAttribL4d_adr := GetFuncAdr('glVertexAttribL4d');
private z_VertexAttribL4d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttribL4d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4d(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttribL4d_ovr_0(index, x, y, z, w);
// added in gl4.1
private z_VertexAttribL4dv_adr := GetFuncAdr('glVertexAttribL4dv');
private z_VertexAttribL4dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL4dv_adr);
private z_VertexAttribL4dv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL4dv_ovr_0(index, v[0]) else
z_VertexAttribL4dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; var v: real) :=
z_VertexAttribL4dv_ovr_0(index, v);
private z_VertexAttribL4dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL4dv_ovr_2(index, v);
// added in gl4.3
private z_VertexAttribLFormat_adr := GetFuncAdr('glVertexAttribLFormat');
private z_VertexAttribLFormat_ovr_0 := GetFuncOrNil&<procedure(attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32)>(z_VertexAttribLFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLFormat(attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32) :=
z_VertexAttribLFormat_ovr_0(attribindex, size, &type, relativeoffset);
// added in gl4.1
private z_VertexAttribLPointer_adr := GetFuncAdr('glVertexAttribLPointer');
private z_VertexAttribLPointer_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr)>(z_VertexAttribLPointer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLPointer(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexAttribLPointer_ovr_0(index, size, &type, stride, pointer);
// added in gl3.3
private z_VertexAttribP1ui_adr := GetFuncAdr('glVertexAttribP1ui');
private z_VertexAttribP1ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32)>(z_VertexAttribP1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP1ui_ovr_0(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP1uiv_adr := GetFuncAdr('glVertexAttribP1uiv');
private z_VertexAttribP1uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP1uiv_adr);
private z_VertexAttribP1uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP1uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value);
private z_VertexAttribP1uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP1uiv_ovr_2(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP2ui_adr := GetFuncAdr('glVertexAttribP2ui');
private z_VertexAttribP2ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32)>(z_VertexAttribP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP2ui_ovr_0(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP2uiv_adr := GetFuncAdr('glVertexAttribP2uiv');
private z_VertexAttribP2uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP2uiv_adr);
private z_VertexAttribP2uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP2uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value);
private z_VertexAttribP2uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP2uiv_ovr_2(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP3ui_adr := GetFuncAdr('glVertexAttribP3ui');
private z_VertexAttribP3ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32)>(z_VertexAttribP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP3ui_ovr_0(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP3uiv_adr := GetFuncAdr('glVertexAttribP3uiv');
private z_VertexAttribP3uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP3uiv_adr);
private z_VertexAttribP3uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP3uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value);
private z_VertexAttribP3uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP3uiv_ovr_2(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP4ui_adr := GetFuncAdr('glVertexAttribP4ui');
private z_VertexAttribP4ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32)>(z_VertexAttribP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP4ui_ovr_0(index, &type, normalized, value);
// added in gl3.3
private z_VertexAttribP4uiv_adr := GetFuncAdr('glVertexAttribP4uiv');
private z_VertexAttribP4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP4uiv_adr);
private z_VertexAttribP4uiv_ovr_0_anh00001 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP4uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value);
private z_VertexAttribP4uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr)>(z_VertexAttribP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP4uiv_ovr_2(index, &type, normalized, value);
// added in gl2.0
private z_VertexAttribPointer_adr := GetFuncAdr('glVertexAttribPointer');
private z_VertexAttribPointer_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr)>(z_VertexAttribPointer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointer(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr) :=
z_VertexAttribPointer_ovr_0(index, size, &type, normalized, stride, pointer);
// added in gl4.3
private z_VertexBindingDivisor_adr := GetFuncAdr('glVertexBindingDivisor');
private z_VertexBindingDivisor_ovr_0 := GetFuncOrNil&<procedure(bindingindex: UInt32; divisor: UInt32)>(z_VertexBindingDivisor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBindingDivisor(bindingindex: UInt32; divisor: UInt32) :=
z_VertexBindingDivisor_ovr_0(bindingindex, divisor);
// added in gl3.3
private z_VertexP2ui_adr := GetFuncAdr('glVertexP2ui');
private z_VertexP2ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP2ui_ovr_0(&type, value);
// added in gl3.3
private z_VertexP2uiv_adr := GetFuncAdr('glVertexP2uiv');
private z_VertexP2uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP2uiv_adr);
private z_VertexP2uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP2uiv_ovr_0(&type, value[0]) else
z_VertexP2uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP2uiv_ovr_0(&type, value);
private z_VertexP2uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP2uiv_ovr_2(&type, value);
// added in gl3.3
private z_VertexP3ui_adr := GetFuncAdr('glVertexP3ui');
private z_VertexP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP3ui_ovr_0(&type, value);
// added in gl3.3
private z_VertexP3uiv_adr := GetFuncAdr('glVertexP3uiv');
private z_VertexP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP3uiv_adr);
private z_VertexP3uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP3uiv_ovr_0(&type, value[0]) else
z_VertexP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP3uiv_ovr_0(&type, value);
private z_VertexP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP3uiv_ovr_2(&type, value);
// added in gl3.3
private z_VertexP4ui_adr := GetFuncAdr('glVertexP4ui');
private z_VertexP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP4ui_ovr_0(&type, value);
// added in gl3.3
private z_VertexP4uiv_adr := GetFuncAdr('glVertexP4uiv');
private z_VertexP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP4uiv_adr);
private z_VertexP4uiv_ovr_0_anh001 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP4uiv_ovr_0(&type, value[0]) else
z_VertexP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP4uiv_ovr_0(&type, value);
private z_VertexP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP4uiv_ovr_2(&type, value);
// added in gl1.0
private static procedure z_Viewport_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glViewport';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Viewport(x: Int32; y: Int32; width: Int32; height: Int32) :=
z_Viewport_ovr_0(x, y, width, height);
// added in gl4.1
private z_ViewportArrayv_adr := GetFuncAdr('glViewportArrayv');
private z_ViewportArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: single)>(z_ViewportArrayv_adr);
private z_ViewportArrayv_ovr_0_anh0001 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_ViewportArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ViewportArrayv_ovr_0(first, count, v[0]) else
z_ViewportArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; var v: single) :=
z_ViewportArrayv_ovr_0(first, count, v);
private z_ViewportArrayv_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_ViewportArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_ViewportArrayv_ovr_2(first, count, v);
// added in gl4.1
private z_ViewportIndexedf_adr := GetFuncAdr('glViewportIndexedf');
private z_ViewportIndexedf_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; w: single; h: single)>(z_ViewportIndexedf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedf(index: UInt32; x: single; y: single; w: single; h: single) :=
z_ViewportIndexedf_ovr_0(index, x, y, w, h);
// added in gl4.1
private z_ViewportIndexedfv_adr := GetFuncAdr('glViewportIndexedfv');
private z_ViewportIndexedfv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_ViewportIndexedfv_adr);
private z_ViewportIndexedfv_ovr_0_anh001 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ViewportIndexedfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ViewportIndexedfv_ovr_0(index, v[0]) else
z_ViewportIndexedfv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; var v: single) :=
z_ViewportIndexedfv_ovr_0(index, v);
private z_ViewportIndexedfv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ViewportIndexedfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: IntPtr) :=
z_ViewportIndexedfv_ovr_2(index, v);
// added in gl3.2
private z_WaitSync_adr := GetFuncAdr('glWaitSync');
private z_WaitSync_ovr_0 := GetFuncOrNil&<procedure(sync: GLsync; flags: DummyFlags; timeout: UInt64)>(z_WaitSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSync(sync: GLsync; flags: DummyFlags; timeout: UInt64) :=
z_WaitSync_ovr_0(sync, flags, timeout);
end;
[PCUNotRestore]
glD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Accum_ovr_0(op: AccumOp; value: single);
external 'opengl32.dll' name 'glAccum';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Accum(op: AccumOp; value: single) :=
z_Accum_ovr_0(op, value);
// added in gl1.0, deprecated in gl3.2
private static procedure z_AlphaFunc_ovr_0(func: AlphaFunction; ref: single);
external 'opengl32.dll' name 'glAlphaFunc';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFunc(func: AlphaFunction; ref: single) :=
z_AlphaFunc_ovr_0(func, ref);
// added in gl1.1, deprecated in gl3.2
private static function z_AreTexturesResident_ovr_0(n: Int32; var textures: UInt32; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
private static function z_AreTexturesResident_ovr_0_anh0010(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
private static function z_AreTexturesResident_ovr_0_anh0001(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
private static function z_AreTexturesResident_ovr_0_anh0011(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; residences: array of boolean): boolean :=
if (textures<>nil) and (textures.Length<>0) then
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResident_ovr_0(n, textures[0], residences[0]) else
z_AreTexturesResident_ovr_0_anh0001(n, textures[0], IntPtr.Zero) else
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResident_ovr_0_anh0010(n, IntPtr.Zero, residences[0]) else
z_AreTexturesResident_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static function z_AreTexturesResident_ovr_1_anh0010(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; var residences: boolean): boolean :=
if (textures<>nil) and (textures.Length<>0) then
z_AreTexturesResident_ovr_0(n, textures[0], residences) else
z_AreTexturesResident_ovr_0_anh0010(n, IntPtr.Zero, residences);
private static function z_AreTexturesResident_ovr_2(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
private static function z_AreTexturesResident_ovr_2_anh0010(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; residences: IntPtr): boolean :=
if (textures<>nil) and (textures.Length<>0) then
z_AreTexturesResident_ovr_2(n, textures[0], residences) else
z_AreTexturesResident_ovr_2_anh0010(n, IntPtr.Zero, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResident_ovr_0(n, textures, residences[0]) else
z_AreTexturesResident_ovr_0_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; var residences: boolean): boolean :=
z_AreTexturesResident_ovr_0(n, textures, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; residences: IntPtr): boolean :=
z_AreTexturesResident_ovr_2(n, textures, residences);
private static function z_AreTexturesResident_ovr_6(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
private static function z_AreTexturesResident_ovr_6_anh0001(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResident_ovr_6(n, textures, residences[0]) else
z_AreTexturesResident_ovr_6_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; var residences: boolean): boolean :=
z_AreTexturesResident_ovr_6(n, textures, residences);
private static function z_AreTexturesResident_ovr_8(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; residences: IntPtr): boolean :=
z_AreTexturesResident_ovr_8(n, textures, residences);
// added in gl1.1, deprecated in gl3.2
private static procedure z_ArrayElement_ovr_0(i: Int32);
external 'opengl32.dll' name 'glArrayElement';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayElement(i: Int32) :=
z_ArrayElement_ovr_0(i);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Begin_ovr_0(mode: PrimitiveType);
external 'opengl32.dll' name 'glBegin';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure &Begin(mode: PrimitiveType) :=
z_Begin_ovr_0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Bitmap_ovr_0(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; var bitmap: Byte);
external 'opengl32.dll' name 'glBitmap';
private static procedure z_Bitmap_ovr_0_anh00000001(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: IntPtr);
external 'opengl32.dll' name 'glBitmap';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: array of Byte) :=
if (bitmap<>nil) and (bitmap.Length<>0) then
z_Bitmap_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap[0]) else
z_Bitmap_ovr_0_anh00000001(width, height, xorig, yorig, xmove, ymove, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; var bitmap: Byte) :=
z_Bitmap_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap);
private static procedure z_Bitmap_ovr_2(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: IntPtr);
external 'opengl32.dll' name 'glBitmap';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: IntPtr) :=
z_Bitmap_ovr_2(width, height, xorig, yorig, xmove, ymove, bitmap);
// added in gl1.0, deprecated in gl3.2
private static procedure z_CallList_ovr_0(list: UInt32);
external 'opengl32.dll' name 'glCallList';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallList(list: UInt32) :=
z_CallList_ovr_0(list);
// added in gl1.0, deprecated in gl3.2
private static procedure z_CallLists_ovr_0(n: Int32; &type: ListNameType; lists: IntPtr);
external 'opengl32.dll' name 'glCallLists';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallLists(n: Int32; &type: ListNameType; lists: IntPtr) :=
z_CallLists_ovr_0(n, &type, lists);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ClearAccum_ovr_0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glClearAccum';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearAccum(red: single; green: single; blue: single; alpha: single) :=
z_ClearAccum_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ClearIndex_ovr_0(c: single);
external 'opengl32.dll' name 'glClearIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearIndex(c: single) :=
z_ClearIndex_ovr_0(c);
// added in gl1.3, deprecated in gl3.2
private z_ClientActiveTexture_adr := GetFuncAdr('glClientActiveTexture');
private z_ClientActiveTexture_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ClientActiveTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveTexture(texture: TextureUnit) :=
z_ClientActiveTexture_ovr_0(texture);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ClipPlane_ovr_0(plane: ClipPlaneName; var equation: real);
external 'opengl32.dll' name 'glClipPlane';
private static procedure z_ClipPlane_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; equation: array of real) :=
if (equation<>nil) and (equation.Length<>0) then
z_ClipPlane_ovr_0(plane, equation[0]) else
z_ClipPlane_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; var equation: real) :=
z_ClipPlane_ovr_0(plane, equation);
private static procedure z_ClipPlane_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; equation: IntPtr) :=
z_ClipPlane_ovr_2(plane, equation);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3b_ovr_0(red: SByte; green: SByte; blue: SByte);
external 'opengl32.dll' name 'glColor3b';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3b(red: SByte; green: SByte; blue: SByte) :=
z_Color3b_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3bv_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glColor3bv';
private static procedure z_Color3bv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_Color3bv_ovr_0(v[0]) else
z_Color3bv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(var v: SByte) :=
z_Color3bv_ovr_0(v);
private static procedure z_Color3bv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(v: IntPtr) :=
z_Color3bv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3d_ovr_0(red: real; green: real; blue: real);
external 'opengl32.dll' name 'glColor3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3d(red: real; green: real; blue: real) :=
z_Color3d_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glColor3dv';
private static procedure z_Color3dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Color3dv_ovr_0(v[0]) else
z_Color3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(var v: real) :=
z_Color3dv_ovr_0(v);
private static procedure z_Color3dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(v: IntPtr) :=
z_Color3dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3f_ovr_0(red: single; green: single; blue: single);
external 'opengl32.dll' name 'glColor3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3f(red: single; green: single; blue: single) :=
z_Color3f_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glColor3fv';
private static procedure z_Color3fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Color3fv_ovr_0(v[0]) else
z_Color3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(var v: single) :=
z_Color3fv_ovr_0(v);
private static procedure z_Color3fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(v: IntPtr) :=
z_Color3fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3i_ovr_0(red: Int32; green: Int32; blue: Int32);
external 'opengl32.dll' name 'glColor3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3i(red: Int32; green: Int32; blue: Int32) :=
z_Color3i_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glColor3iv';
private static procedure z_Color3iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Color3iv_ovr_0(v[0]) else
z_Color3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(var v: Int32) :=
z_Color3iv_ovr_0(v);
private static procedure z_Color3iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(v: IntPtr) :=
z_Color3iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3s_ovr_0(red: Int16; green: Int16; blue: Int16);
external 'opengl32.dll' name 'glColor3s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3s(red: Int16; green: Int16; blue: Int16) :=
z_Color3s_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glColor3sv';
private static procedure z_Color3sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Color3sv_ovr_0(v[0]) else
z_Color3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(var v: Int16) :=
z_Color3sv_ovr_0(v);
private static procedure z_Color3sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(v: IntPtr) :=
z_Color3sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3ub_ovr_0(red: Byte; green: Byte; blue: Byte);
external 'opengl32.dll' name 'glColor3ub';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ub(red: Byte; green: Byte; blue: Byte) :=
z_Color3ub_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3ubv_ovr_0(var v: Byte);
external 'opengl32.dll' name 'glColor3ubv';
private static procedure z_Color3ubv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3ubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_Color3ubv_ovr_0(v[0]) else
z_Color3ubv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(var v: Byte) :=
z_Color3ubv_ovr_0(v);
private static procedure z_Color3ubv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3ubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(v: IntPtr) :=
z_Color3ubv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3ui_ovr_0(red: UInt32; green: UInt32; blue: UInt32);
external 'opengl32.dll' name 'glColor3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ui(red: UInt32; green: UInt32; blue: UInt32) :=
z_Color3ui_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3uiv_ovr_0(var v: UInt32);
external 'opengl32.dll' name 'glColor3uiv';
private static procedure z_Color3uiv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_Color3uiv_ovr_0(v[0]) else
z_Color3uiv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(var v: UInt32) :=
z_Color3uiv_ovr_0(v);
private static procedure z_Color3uiv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(v: IntPtr) :=
z_Color3uiv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3us_ovr_0(red: UInt16; green: UInt16; blue: UInt16);
external 'opengl32.dll' name 'glColor3us';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3us(red: UInt16; green: UInt16; blue: UInt16) :=
z_Color3us_ovr_0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color3usv_ovr_0(var v: UInt16);
external 'opengl32.dll' name 'glColor3usv';
private static procedure z_Color3usv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3usv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_Color3usv_ovr_0(v[0]) else
z_Color3usv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(var v: UInt16) :=
z_Color3usv_ovr_0(v);
private static procedure z_Color3usv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3usv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(v: IntPtr) :=
z_Color3usv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4b_ovr_0(red: SByte; green: SByte; blue: SByte; alpha: SByte);
external 'opengl32.dll' name 'glColor4b';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4b(red: SByte; green: SByte; blue: SByte; alpha: SByte) :=
z_Color4b_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4bv_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glColor4bv';
private static procedure z_Color4bv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_Color4bv_ovr_0(v[0]) else
z_Color4bv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(var v: SByte) :=
z_Color4bv_ovr_0(v);
private static procedure z_Color4bv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(v: IntPtr) :=
z_Color4bv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4d_ovr_0(red: real; green: real; blue: real; alpha: real);
external 'opengl32.dll' name 'glColor4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4d(red: real; green: real; blue: real; alpha: real) :=
z_Color4d_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glColor4dv';
private static procedure z_Color4dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Color4dv_ovr_0(v[0]) else
z_Color4dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(var v: real) :=
z_Color4dv_ovr_0(v);
private static procedure z_Color4dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(v: IntPtr) :=
z_Color4dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4f_ovr_0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glColor4f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4f(red: single; green: single; blue: single; alpha: single) :=
z_Color4f_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glColor4fv';
private static procedure z_Color4fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Color4fv_ovr_0(v[0]) else
z_Color4fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(var v: single) :=
z_Color4fv_ovr_0(v);
private static procedure z_Color4fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(v: IntPtr) :=
z_Color4fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4i_ovr_0(red: Int32; green: Int32; blue: Int32; alpha: Int32);
external 'opengl32.dll' name 'glColor4i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4i(red: Int32; green: Int32; blue: Int32; alpha: Int32) :=
z_Color4i_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glColor4iv';
private static procedure z_Color4iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Color4iv_ovr_0(v[0]) else
z_Color4iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(var v: Int32) :=
z_Color4iv_ovr_0(v);
private static procedure z_Color4iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(v: IntPtr) :=
z_Color4iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4s_ovr_0(red: Int16; green: Int16; blue: Int16; alpha: Int16);
external 'opengl32.dll' name 'glColor4s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4s(red: Int16; green: Int16; blue: Int16; alpha: Int16) :=
z_Color4s_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glColor4sv';
private static procedure z_Color4sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Color4sv_ovr_0(v[0]) else
z_Color4sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(var v: Int16) :=
z_Color4sv_ovr_0(v);
private static procedure z_Color4sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(v: IntPtr) :=
z_Color4sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4ub_ovr_0(red: Byte; green: Byte; blue: Byte; alpha: Byte);
external 'opengl32.dll' name 'glColor4ub';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ub(red: Byte; green: Byte; blue: Byte; alpha: Byte) :=
z_Color4ub_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4ubv_ovr_0(var v: Byte);
external 'opengl32.dll' name 'glColor4ubv';
private static procedure z_Color4ubv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4ubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_Color4ubv_ovr_0(v[0]) else
z_Color4ubv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(var v: Byte) :=
z_Color4ubv_ovr_0(v);
private static procedure z_Color4ubv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4ubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(v: IntPtr) :=
z_Color4ubv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4ui_ovr_0(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32);
external 'opengl32.dll' name 'glColor4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ui(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32) :=
z_Color4ui_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4uiv_ovr_0(var v: UInt32);
external 'opengl32.dll' name 'glColor4uiv';
private static procedure z_Color4uiv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_Color4uiv_ovr_0(v[0]) else
z_Color4uiv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(var v: UInt32) :=
z_Color4uiv_ovr_0(v);
private static procedure z_Color4uiv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(v: IntPtr) :=
z_Color4uiv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4us_ovr_0(red: UInt16; green: UInt16; blue: UInt16; alpha: UInt16);
external 'opengl32.dll' name 'glColor4us';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4us(red: UInt16; green: UInt16; blue: UInt16; alpha: UInt16) :=
z_Color4us_ovr_0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Color4usv_ovr_0(var v: UInt16);
external 'opengl32.dll' name 'glColor4usv';
private static procedure z_Color4usv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4usv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_Color4usv_ovr_0(v[0]) else
z_Color4usv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(var v: UInt16) :=
z_Color4usv_ovr_0(v);
private static procedure z_Color4usv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4usv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(v: IntPtr) :=
z_Color4usv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ColorMaterial_ovr_0(face: MaterialFace; mode: ColorMaterialParameter);
external 'opengl32.dll' name 'glColorMaterial';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMaterial(face: MaterialFace; mode: ColorMaterialParameter) :=
z_ColorMaterial_ovr_0(face, mode);
// added in gl1.1, deprecated in gl3.2
private static procedure z_ColorPointer_ovr_0(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glColorPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointer(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr) :=
z_ColorPointer_ovr_0(size, &type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_CopyPixels_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32; &type: PixelCopyType);
external 'opengl32.dll' name 'glCopyPixels';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyPixels(x: Int32; y: Int32; width: Int32; height: Int32; &type: PixelCopyType) :=
z_CopyPixels_ovr_0(x, y, width, height, &type);
// added in gl1.0, deprecated in gl3.2
private static procedure z_DeleteLists_ovr_0(list: UInt32; range: Int32);
external 'opengl32.dll' name 'glDeleteLists';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteLists(list: UInt32; range: Int32) :=
z_DeleteLists_ovr_0(list, range);
// added in gl1.1, deprecated in gl3.2
private static procedure z_DisableClientState_ovr_0(&array: EnableCap);
external 'opengl32.dll' name 'glDisableClientState';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientState(&array: EnableCap) :=
z_DisableClientState_ovr_0(&array);
// added in gl1.0, deprecated in gl3.2
private static procedure z_DrawPixels_ovr_0(width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glDrawPixels';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawPixels(width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_DrawPixels_ovr_0(width, height, format, &type, pixels);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EdgeFlag_ovr_0(flag: boolean);
external 'opengl32.dll' name 'glEdgeFlag';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlag(flag: boolean) :=
z_EdgeFlag_ovr_0(flag);
// added in gl1.1, deprecated in gl3.2
private static procedure z_EdgeFlagPointer_ovr_0(stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointer(stride: Int32; pointer: IntPtr) :=
z_EdgeFlagPointer_ovr_0(stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EdgeFlagv_ovr_0(var flag: boolean);
external 'opengl32.dll' name 'glEdgeFlagv';
private static procedure z_EdgeFlagv_ovr_0_anh01(flag: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(flag: array of boolean) :=
if (flag<>nil) and (flag.Length<>0) then
z_EdgeFlagv_ovr_0(flag[0]) else
z_EdgeFlagv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(var flag: boolean) :=
z_EdgeFlagv_ovr_0(flag);
private static procedure z_EdgeFlagv_ovr_2(flag: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(flag: IntPtr) :=
z_EdgeFlagv_ovr_2(flag);
// added in gl1.1, deprecated in gl3.2
private static procedure z_EnableClientState_ovr_0(&array: EnableCap);
external 'opengl32.dll' name 'glEnableClientState';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientState(&array: EnableCap) :=
z_EnableClientState_ovr_0(&array);
// added in gl1.0, deprecated in gl3.2
private static procedure z_End_ovr_0;
external 'opengl32.dll' name 'glEnd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure &End :=
z_End_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_EndList_ovr_0;
external 'opengl32.dll' name 'glEndList';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndList :=
z_EndList_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord1d_ovr_0(u: real);
external 'opengl32.dll' name 'glEvalCoord1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1d(u: real) :=
z_EvalCoord1d_ovr_0(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord1dv_ovr_0(var u: real);
external 'opengl32.dll' name 'glEvalCoord1dv';
private static procedure z_EvalCoord1dv_ovr_0_anh01(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(u: array of real) :=
if (u<>nil) and (u.Length<>0) then
z_EvalCoord1dv_ovr_0(u[0]) else
z_EvalCoord1dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(var u: real) :=
z_EvalCoord1dv_ovr_0(u);
private static procedure z_EvalCoord1dv_ovr_2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(u: IntPtr) :=
z_EvalCoord1dv_ovr_2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord1f_ovr_0(u: single);
external 'opengl32.dll' name 'glEvalCoord1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1f(u: single) :=
z_EvalCoord1f_ovr_0(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord1fv_ovr_0(var u: single);
external 'opengl32.dll' name 'glEvalCoord1fv';
private static procedure z_EvalCoord1fv_ovr_0_anh01(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(u: array of single) :=
if (u<>nil) and (u.Length<>0) then
z_EvalCoord1fv_ovr_0(u[0]) else
z_EvalCoord1fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(var u: single) :=
z_EvalCoord1fv_ovr_0(u);
private static procedure z_EvalCoord1fv_ovr_2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(u: IntPtr) :=
z_EvalCoord1fv_ovr_2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord2d_ovr_0(u: real; v: real);
external 'opengl32.dll' name 'glEvalCoord2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2d(u: real; v: real) :=
z_EvalCoord2d_ovr_0(u, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord2dv_ovr_0(var u: real);
external 'opengl32.dll' name 'glEvalCoord2dv';
private static procedure z_EvalCoord2dv_ovr_0_anh01(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(u: array of real) :=
if (u<>nil) and (u.Length<>0) then
z_EvalCoord2dv_ovr_0(u[0]) else
z_EvalCoord2dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(var u: real) :=
z_EvalCoord2dv_ovr_0(u);
private static procedure z_EvalCoord2dv_ovr_2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(u: IntPtr) :=
z_EvalCoord2dv_ovr_2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord2f_ovr_0(u: single; v: single);
external 'opengl32.dll' name 'glEvalCoord2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2f(u: single; v: single) :=
z_EvalCoord2f_ovr_0(u, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalCoord2fv_ovr_0(var u: single);
external 'opengl32.dll' name 'glEvalCoord2fv';
private static procedure z_EvalCoord2fv_ovr_0_anh01(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(u: array of single) :=
if (u<>nil) and (u.Length<>0) then
z_EvalCoord2fv_ovr_0(u[0]) else
z_EvalCoord2fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(var u: single) :=
z_EvalCoord2fv_ovr_0(u);
private static procedure z_EvalCoord2fv_ovr_2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(u: IntPtr) :=
z_EvalCoord2fv_ovr_2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalMesh1_ovr_0(mode: MeshMode1; i1: Int32; i2: Int32);
external 'opengl32.dll' name 'glEvalMesh1';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMesh1(mode: MeshMode1; i1: Int32; i2: Int32) :=
z_EvalMesh1_ovr_0(mode, i1, i2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalMesh2_ovr_0(mode: MeshMode2; i1: Int32; i2: Int32; j1: Int32; j2: Int32);
external 'opengl32.dll' name 'glEvalMesh2';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMesh2(mode: MeshMode2; i1: Int32; i2: Int32; j1: Int32; j2: Int32) :=
z_EvalMesh2_ovr_0(mode, i1, i2, j1, j2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalPoint1_ovr_0(i: Int32);
external 'opengl32.dll' name 'glEvalPoint1';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalPoint1(i: Int32) :=
z_EvalPoint1_ovr_0(i);
// added in gl1.0, deprecated in gl3.2
private static procedure z_EvalPoint2_ovr_0(i: Int32; j: Int32);
external 'opengl32.dll' name 'glEvalPoint2';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalPoint2(i: Int32; j: Int32) :=
z_EvalPoint2_ovr_0(i, j);
// added in gl1.0, deprecated in gl3.2
private static procedure z_FeedbackBuffer_ovr_0(size: Int32; &type: FeedbackType; var buffer: single);
external 'opengl32.dll' name 'glFeedbackBuffer';
private static procedure z_FeedbackBuffer_ovr_0_anh0001(size: Int32; &type: FeedbackType; buffer: IntPtr);
external 'opengl32.dll' name 'glFeedbackBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; buffer: array of single) :=
if (buffer<>nil) and (buffer.Length<>0) then
z_FeedbackBuffer_ovr_0(size, &type, buffer[0]) else
z_FeedbackBuffer_ovr_0_anh0001(size, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; var buffer: single) :=
z_FeedbackBuffer_ovr_0(size, &type, buffer);
private static procedure z_FeedbackBuffer_ovr_2(size: Int32; &type: FeedbackType; buffer: IntPtr);
external 'opengl32.dll' name 'glFeedbackBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; buffer: IntPtr) :=
z_FeedbackBuffer_ovr_2(size, &type, buffer);
// added in gl1.4, deprecated in gl3.2
private z_FogCoordd_adr := GetFuncAdr('glFogCoordd');
private z_FogCoordd_ovr_0 := GetFuncOrNil&<procedure(coord: real)>(z_FogCoordd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordd(coord: real) :=
z_FogCoordd_ovr_0(coord);
// added in gl1.4, deprecated in gl3.2
private z_FogCoorddv_adr := GetFuncAdr('glFogCoorddv');
private z_FogCoorddv_ovr_0 := GetFuncOrNil&<procedure(var coord: real)>(z_FogCoorddv_adr);
private z_FogCoorddv_ovr_0_anh01 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoorddv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(coord: array of real) :=
if (coord<>nil) and (coord.Length<>0) then
z_FogCoorddv_ovr_0(coord[0]) else
z_FogCoorddv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(var coord: real) :=
z_FogCoorddv_ovr_0(coord);
private z_FogCoorddv_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoorddv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(coord: IntPtr) :=
z_FogCoorddv_ovr_2(coord);
// added in gl1.4, deprecated in gl3.2
private z_FogCoordf_adr := GetFuncAdr('glFogCoordf');
private z_FogCoordf_ovr_0 := GetFuncOrNil&<procedure(coord: single)>(z_FogCoordf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordf(coord: single) :=
z_FogCoordf_ovr_0(coord);
// added in gl1.4, deprecated in gl3.2
private z_FogCoordfv_adr := GetFuncAdr('glFogCoordfv');
private z_FogCoordfv_ovr_0 := GetFuncOrNil&<procedure(var coord: single)>(z_FogCoordfv_adr);
private z_FogCoordfv_ovr_0_anh01 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoordfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(coord: array of single) :=
if (coord<>nil) and (coord.Length<>0) then
z_FogCoordfv_ovr_0(coord[0]) else
z_FogCoordfv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(var coord: single) :=
z_FogCoordfv_ovr_0(coord);
private z_FogCoordfv_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoordfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(coord: IntPtr) :=
z_FogCoordfv_ovr_2(coord);
// added in gl1.4, deprecated in gl3.2
private z_FogCoordPointer_adr := GetFuncAdr('glFogCoordPointer');
private z_FogCoordPointer_ovr_0 := GetFuncOrNil&<procedure(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr)>(z_FogCoordPointer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointer(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr) :=
z_FogCoordPointer_ovr_0(&type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Fogf_ovr_0(pname: FogParameter; param: single);
external 'opengl32.dll' name 'glFogf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogf(pname: FogParameter; param: single) :=
z_Fogf_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Fogfv_ovr_0(pname: FogParameter; var ¶ms: single);
external 'opengl32.dll' name 'glFogfv';
private static procedure z_Fogfv_ovr_0_anh001(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Fogfv_ovr_0(pname, ¶ms[0]) else
z_Fogfv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; var ¶ms: single) :=
z_Fogfv_ovr_0(pname, ¶ms);
private static procedure z_Fogfv_ovr_2(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; ¶ms: IntPtr) :=
z_Fogfv_ovr_2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Fogi_ovr_0(pname: FogParameter; param: Int32);
external 'opengl32.dll' name 'glFogi';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogi(pname: FogParameter; param: Int32) :=
z_Fogi_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Fogiv_ovr_0(pname: FogParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glFogiv';
private static procedure z_Fogiv_ovr_0_anh001(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Fogiv_ovr_0(pname, ¶ms[0]) else
z_Fogiv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; var ¶ms: Int32) :=
z_Fogiv_ovr_0(pname, ¶ms);
private static procedure z_Fogiv_ovr_2(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; ¶ms: IntPtr) :=
z_Fogiv_ovr_2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Frustum_ovr_0(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glFrustum';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Frustum(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_Frustum_ovr_0(left, right, bottom, top, zNear, zFar);
// added in gl1.0, deprecated in gl3.2
private static function z_GenLists_ovr_0(range: Int32): UInt32;
external 'opengl32.dll' name 'glGenLists';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenLists(range: Int32): UInt32 :=
z_GenLists_ovr_0(range);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetClipPlane_ovr_0(plane: ClipPlaneName; var equation: real);
external 'opengl32.dll' name 'glGetClipPlane';
private static procedure z_GetClipPlane_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; equation: array of real) :=
if (equation<>nil) and (equation.Length<>0) then
z_GetClipPlane_ovr_0(plane, equation[0]) else
z_GetClipPlane_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; var equation: real) :=
z_GetClipPlane_ovr_0(plane, equation);
private static procedure z_GetClipPlane_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; equation: IntPtr) :=
z_GetClipPlane_ovr_2(plane, equation);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetLightfv_ovr_0(light: LightName; pname: LightParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetLightfv';
private static procedure z_GetLightfv_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetLightfv_ovr_0(light, pname, ¶ms[0]) else
z_GetLightfv_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; var ¶ms: single) :=
z_GetLightfv_ovr_0(light, pname, ¶ms);
private static procedure z_GetLightfv_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_GetLightfv_ovr_2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetLightiv_ovr_0(light: LightName; pname: LightParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetLightiv';
private static procedure z_GetLightiv_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetLightiv_ovr_0(light, pname, ¶ms[0]) else
z_GetLightiv_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; var ¶ms: Int32) :=
z_GetLightiv_ovr_0(light, pname, ¶ms);
private static procedure z_GetLightiv_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_GetLightiv_ovr_2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetMapdv_ovr_0(target: MapTarget; query: GetMapQuery; var v: real);
external 'opengl32.dll' name 'glGetMapdv';
private static procedure z_GetMapdv_ovr_0_anh0001(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_GetMapdv_ovr_0(target, query, v[0]) else
z_GetMapdv_ovr_0_anh0001(target, query, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; var v: real) :=
z_GetMapdv_ovr_0(target, query, v);
private static procedure z_GetMapdv_ovr_2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; v: IntPtr) :=
z_GetMapdv_ovr_2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetMapfv_ovr_0(target: MapTarget; query: GetMapQuery; var v: single);
external 'opengl32.dll' name 'glGetMapfv';
private static procedure z_GetMapfv_ovr_0_anh0001(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_GetMapfv_ovr_0(target, query, v[0]) else
z_GetMapfv_ovr_0_anh0001(target, query, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; var v: single) :=
z_GetMapfv_ovr_0(target, query, v);
private static procedure z_GetMapfv_ovr_2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; v: IntPtr) :=
z_GetMapfv_ovr_2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetMapiv_ovr_0(target: MapTarget; query: GetMapQuery; var v: Int32);
external 'opengl32.dll' name 'glGetMapiv';
private static procedure z_GetMapiv_ovr_0_anh0001(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_GetMapiv_ovr_0(target, query, v[0]) else
z_GetMapiv_ovr_0_anh0001(target, query, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; var v: Int32) :=
z_GetMapiv_ovr_0(target, query, v);
private static procedure z_GetMapiv_ovr_2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; v: IntPtr) :=
z_GetMapiv_ovr_2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetMaterialfv_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMaterialfv';
private static procedure z_GetMaterialfv_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: MaterialFace; pname: MaterialParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMaterialfv_ovr_0(face, pname, ¶ms[0]) else
z_GetMaterialfv_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: MaterialFace; pname: MaterialParameter; var ¶ms: single) :=
z_GetMaterialfv_ovr_0(face, pname, ¶ms);
private static procedure z_GetMaterialfv_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_GetMaterialfv_ovr_2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetMaterialiv_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMaterialiv';
private static procedure z_GetMaterialiv_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: MaterialFace; pname: MaterialParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMaterialiv_ovr_0(face, pname, ¶ms[0]) else
z_GetMaterialiv_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32) :=
z_GetMaterialiv_ovr_0(face, pname, ¶ms);
private static procedure z_GetMaterialiv_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_GetMaterialiv_ovr_2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetPixelMapfv_ovr_0(map: PixelMap; var values: single);
external 'opengl32.dll' name 'glGetPixelMapfv';
private static procedure z_GetPixelMapfv_ovr_0_anh001(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_GetPixelMapfv_ovr_0(map, values[0]) else
z_GetPixelMapfv_ovr_0_anh001(map, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; var values: single) :=
z_GetPixelMapfv_ovr_0(map, values);
private static procedure z_GetPixelMapfv_ovr_2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; values: IntPtr) :=
z_GetPixelMapfv_ovr_2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetPixelMapuiv_ovr_0(map: PixelMap; var values: UInt32);
external 'opengl32.dll' name 'glGetPixelMapuiv';
private static procedure z_GetPixelMapuiv_ovr_0_anh001(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; values: array of UInt32) :=
if (values<>nil) and (values.Length<>0) then
z_GetPixelMapuiv_ovr_0(map, values[0]) else
z_GetPixelMapuiv_ovr_0_anh001(map, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; var values: UInt32) :=
z_GetPixelMapuiv_ovr_0(map, values);
private static procedure z_GetPixelMapuiv_ovr_2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; values: IntPtr) :=
z_GetPixelMapuiv_ovr_2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetPixelMapusv_ovr_0(map: PixelMap; var values: UInt16);
external 'opengl32.dll' name 'glGetPixelMapusv';
private static procedure z_GetPixelMapusv_ovr_0_anh001(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapusv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; values: array of UInt16) :=
if (values<>nil) and (values.Length<>0) then
z_GetPixelMapusv_ovr_0(map, values[0]) else
z_GetPixelMapusv_ovr_0_anh001(map, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; var values: UInt16) :=
z_GetPixelMapusv_ovr_0(map, values);
private static procedure z_GetPixelMapusv_ovr_2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapusv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; values: IntPtr) :=
z_GetPixelMapusv_ovr_2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetPolygonStipple_ovr_0(var mask: Byte);
external 'opengl32.dll' name 'glGetPolygonStipple';
private static procedure z_GetPolygonStipple_ovr_0_anh01(mask: IntPtr);
external 'opengl32.dll' name 'glGetPolygonStipple';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(mask: array of Byte) :=
if (mask<>nil) and (mask.Length<>0) then
z_GetPolygonStipple_ovr_0(mask[0]) else
z_GetPolygonStipple_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(var mask: Byte) :=
z_GetPolygonStipple_ovr_0(mask);
private static procedure z_GetPolygonStipple_ovr_2(mask: IntPtr);
external 'opengl32.dll' name 'glGetPolygonStipple';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(mask: IntPtr) :=
z_GetPolygonStipple_ovr_2(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetTexEnvfv_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexEnvfv';
private static procedure z_GetTexEnvfv_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnvfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexEnvfv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexEnvfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) :=
z_GetTexEnvfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexEnvfv_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnvfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_GetTexEnvfv_ovr_2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetTexEnviv_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexEnviv';
private static procedure z_GetTexEnviv_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnviv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexEnviv_ovr_0(target, pname, ¶ms[0]) else
z_GetTexEnviv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) :=
z_GetTexEnviv_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexEnviv_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnviv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_GetTexEnviv_ovr_2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetTexGendv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glGetTexGendv';
private static procedure z_GetTexGendv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGendv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexGendv_ovr_0(coord, pname, ¶ms[0]) else
z_GetTexGendv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) :=
z_GetTexGendv_ovr_0(coord, pname, ¶ms);
private static procedure z_GetTexGendv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGendv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetTexGendv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetTexGenfv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexGenfv';
private static procedure z_GetTexGenfv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGenfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexGenfv_ovr_0(coord, pname, ¶ms[0]) else
z_GetTexGenfv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) :=
z_GetTexGenfv_ovr_0(coord, pname, ¶ms);
private static procedure z_GetTexGenfv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGenfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetTexGenfv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_GetTexGeniv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexGeniv';
private static procedure z_GetTexGeniv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGeniv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexGeniv_ovr_0(coord, pname, ¶ms[0]) else
z_GetTexGeniv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) :=
z_GetTexGeniv_ovr_0(coord, pname, ¶ms);
private static procedure z_GetTexGeniv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGeniv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetTexGeniv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexd_ovr_0(c: real);
external 'opengl32.dll' name 'glIndexd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexd(c: real) :=
z_Indexd_ovr_0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexdv_ovr_0(var c: real);
external 'opengl32.dll' name 'glIndexdv';
private static procedure z_Indexdv_ovr_0_anh01(c: IntPtr);
external 'opengl32.dll' name 'glIndexdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(c: array of real) :=
if (c<>nil) and (c.Length<>0) then
z_Indexdv_ovr_0(c[0]) else
z_Indexdv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(var c: real) :=
z_Indexdv_ovr_0(c);
private static procedure z_Indexdv_ovr_2(c: IntPtr);
external 'opengl32.dll' name 'glIndexdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(c: IntPtr) :=
z_Indexdv_ovr_2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexf_ovr_0(c: single);
external 'opengl32.dll' name 'glIndexf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexf(c: single) :=
z_Indexf_ovr_0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexfv_ovr_0(var c: single);
external 'opengl32.dll' name 'glIndexfv';
private static procedure z_Indexfv_ovr_0_anh01(c: IntPtr);
external 'opengl32.dll' name 'glIndexfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(c: array of single) :=
if (c<>nil) and (c.Length<>0) then
z_Indexfv_ovr_0(c[0]) else
z_Indexfv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(var c: single) :=
z_Indexfv_ovr_0(c);
private static procedure z_Indexfv_ovr_2(c: IntPtr);
external 'opengl32.dll' name 'glIndexfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(c: IntPtr) :=
z_Indexfv_ovr_2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexi_ovr_0(c: Int32);
external 'opengl32.dll' name 'glIndexi';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexi(c: Int32) :=
z_Indexi_ovr_0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexiv_ovr_0(var c: Int32);
external 'opengl32.dll' name 'glIndexiv';
private static procedure z_Indexiv_ovr_0_anh01(c: IntPtr);
external 'opengl32.dll' name 'glIndexiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(c: array of Int32) :=
if (c<>nil) and (c.Length<>0) then
z_Indexiv_ovr_0(c[0]) else
z_Indexiv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(var c: Int32) :=
z_Indexiv_ovr_0(c);
private static procedure z_Indexiv_ovr_2(c: IntPtr);
external 'opengl32.dll' name 'glIndexiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(c: IntPtr) :=
z_Indexiv_ovr_2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_IndexMask_ovr_0(mask: UInt32);
external 'opengl32.dll' name 'glIndexMask';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexMask(mask: UInt32) :=
z_IndexMask_ovr_0(mask);
// added in gl1.1, deprecated in gl3.2
private static procedure z_IndexPointer_ovr_0(&type: IndexPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glIndexPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointer(&type: IndexPointerType; stride: Int32; pointer: IntPtr) :=
z_IndexPointer_ovr_0(&type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexs_ovr_0(c: Int16);
external 'opengl32.dll' name 'glIndexs';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexs(c: Int16) :=
z_Indexs_ovr_0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Indexsv_ovr_0(var c: Int16);
external 'opengl32.dll' name 'glIndexsv';
private static procedure z_Indexsv_ovr_0_anh01(c: IntPtr);
external 'opengl32.dll' name 'glIndexsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(c: array of Int16) :=
if (c<>nil) and (c.Length<>0) then
z_Indexsv_ovr_0(c[0]) else
z_Indexsv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(var c: Int16) :=
z_Indexsv_ovr_0(c);
private static procedure z_Indexsv_ovr_2(c: IntPtr);
external 'opengl32.dll' name 'glIndexsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(c: IntPtr) :=
z_Indexsv_ovr_2(c);
// added in gl1.1, deprecated in gl3.2
private static procedure z_Indexub_ovr_0(c: Byte);
external 'opengl32.dll' name 'glIndexub';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexub(c: Byte) :=
z_Indexub_ovr_0(c);
// added in gl1.1, deprecated in gl3.2
private static procedure z_Indexubv_ovr_0(var c: Byte);
external 'opengl32.dll' name 'glIndexubv';
private static procedure z_Indexubv_ovr_0_anh01(c: IntPtr);
external 'opengl32.dll' name 'glIndexubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(c: array of Byte) :=
if (c<>nil) and (c.Length<>0) then
z_Indexubv_ovr_0(c[0]) else
z_Indexubv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(var c: Byte) :=
z_Indexubv_ovr_0(c);
private static procedure z_Indexubv_ovr_2(c: IntPtr);
external 'opengl32.dll' name 'glIndexubv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(c: IntPtr) :=
z_Indexubv_ovr_2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure z_InitNames_ovr_0;
external 'opengl32.dll' name 'glInitNames';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InitNames :=
z_InitNames_ovr_0;
// added in gl1.1, deprecated in gl3.2
private static procedure z_InterleavedArrays_ovr_0(format: InterleavedArrayFormat; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glInterleavedArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InterleavedArrays(format: InterleavedArrayFormat; stride: Int32; pointer: IntPtr) :=
z_InterleavedArrays_ovr_0(format, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static function z_IsList_ovr_0(list: UInt32): boolean;
external 'opengl32.dll' name 'glIsList';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsList(list: UInt32): boolean :=
z_IsList_ovr_0(list);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Lightf_ovr_0(light: LightName; pname: LightParameter; param: single);
external 'opengl32.dll' name 'glLightf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightf(light: LightName; pname: LightParameter; param: single) :=
z_Lightf_ovr_0(light, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Lightfv_ovr_0(light: LightName; pname: LightParameter; var ¶ms: single);
external 'opengl32.dll' name 'glLightfv';
private static procedure z_Lightfv_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Lightfv_ovr_0(light, pname, ¶ms[0]) else
z_Lightfv_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; var ¶ms: single) :=
z_Lightfv_ovr_0(light, pname, ¶ms);
private static procedure z_Lightfv_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_Lightfv_ovr_2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Lighti_ovr_0(light: LightName; pname: LightParameter; param: Int32);
external 'opengl32.dll' name 'glLighti';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lighti(light: LightName; pname: LightParameter; param: Int32) :=
z_Lighti_ovr_0(light, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Lightiv_ovr_0(light: LightName; pname: LightParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glLightiv';
private static procedure z_Lightiv_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Lightiv_ovr_0(light, pname, ¶ms[0]) else
z_Lightiv_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; var ¶ms: Int32) :=
z_Lightiv_ovr_0(light, pname, ¶ms);
private static procedure z_Lightiv_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_Lightiv_ovr_2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LightModelf_ovr_0(pname: LightModelParameter; param: single);
external 'opengl32.dll' name 'glLightModelf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelf(pname: LightModelParameter; param: single) :=
z_LightModelf_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LightModelfv_ovr_0(pname: LightModelParameter; var ¶ms: single);
external 'opengl32.dll' name 'glLightModelfv';
private static procedure z_LightModelfv_ovr_0_anh001(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModelfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_LightModelfv_ovr_0(pname, ¶ms[0]) else
z_LightModelfv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; var ¶ms: single) :=
z_LightModelfv_ovr_0(pname, ¶ms);
private static procedure z_LightModelfv_ovr_2(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModelfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; ¶ms: IntPtr) :=
z_LightModelfv_ovr_2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LightModeli_ovr_0(pname: LightModelParameter; param: Int32);
external 'opengl32.dll' name 'glLightModeli';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeli(pname: LightModelParameter; param: Int32) :=
z_LightModeli_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LightModeliv_ovr_0(pname: LightModelParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glLightModeliv';
private static procedure z_LightModeliv_ovr_0_anh001(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModeliv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_LightModeliv_ovr_0(pname, ¶ms[0]) else
z_LightModeliv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; var ¶ms: Int32) :=
z_LightModeliv_ovr_0(pname, ¶ms);
private static procedure z_LightModeliv_ovr_2(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModeliv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; ¶ms: IntPtr) :=
z_LightModeliv_ovr_2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LineStipple_ovr_0(factor: Int32; pattern: UInt16);
external 'opengl32.dll' name 'glLineStipple';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineStipple(factor: Int32; pattern: UInt16) :=
z_LineStipple_ovr_0(factor, pattern);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ListBase_ovr_0(base: UInt32);
external 'opengl32.dll' name 'glListBase';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListBase(base: UInt32) :=
z_ListBase_ovr_0(base);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LoadIdentity_ovr_0;
external 'opengl32.dll' name 'glLoadIdentity';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadIdentity :=
z_LoadIdentity_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_LoadMatrixd_ovr_0(var m: real);
external 'opengl32.dll' name 'glLoadMatrixd';
private static procedure z_LoadMatrixd_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_LoadMatrixd_ovr_0(m[0]) else
z_LoadMatrixd_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(var m: real) :=
z_LoadMatrixd_ovr_0(m);
private static procedure z_LoadMatrixd_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(m: IntPtr) :=
z_LoadMatrixd_ovr_2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LoadMatrixf_ovr_0(var m: single);
external 'opengl32.dll' name 'glLoadMatrixf';
private static procedure z_LoadMatrixf_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_LoadMatrixf_ovr_0(m[0]) else
z_LoadMatrixf_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(var m: single) :=
z_LoadMatrixf_ovr_0(m);
private static procedure z_LoadMatrixf_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(m: IntPtr) :=
z_LoadMatrixf_ovr_2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure z_LoadName_ovr_0(name: UInt32);
external 'opengl32.dll' name 'glLoadName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadName(name: UInt32) :=
z_LoadName_ovr_0(name);
// added in gl1.3, deprecated in gl3.2
private z_LoadTransposeMatrixd_adr := GetFuncAdr('glLoadTransposeMatrixd');
private z_LoadTransposeMatrixd_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_LoadTransposeMatrixd_adr);
private z_LoadTransposeMatrixd_ovr_0_anh01 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_LoadTransposeMatrixd_ovr_0(m[0]) else
z_LoadTransposeMatrixd_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(var m: real) :=
z_LoadTransposeMatrixd_ovr_0(m);
private z_LoadTransposeMatrixd_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(m: IntPtr) :=
z_LoadTransposeMatrixd_ovr_2(m);
// added in gl1.3, deprecated in gl3.2
private z_LoadTransposeMatrixf_adr := GetFuncAdr('glLoadTransposeMatrixf');
private z_LoadTransposeMatrixf_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_LoadTransposeMatrixf_adr);
private z_LoadTransposeMatrixf_ovr_0_anh01 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_LoadTransposeMatrixf_ovr_0(m[0]) else
z_LoadTransposeMatrixf_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(var m: single) :=
z_LoadTransposeMatrixf_ovr_0(m);
private z_LoadTransposeMatrixf_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(m: IntPtr) :=
z_LoadTransposeMatrixf_ovr_2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Map1d_ovr_0(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; var points: real);
external 'opengl32.dll' name 'glMap1d';
private static procedure z_Map1d_ovr_0_anh0000001(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: array of real) :=
if (points<>nil) and (points.Length<>0) then
z_Map1d_ovr_0(target, u1, u2, stride, order, points[0]) else
z_Map1d_ovr_0_anh0000001(target, u1, u2, stride, order, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; var points: real) :=
z_Map1d_ovr_0(target, u1, u2, stride, order, points);
private static procedure z_Map1d_ovr_2(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr) :=
z_Map1d_ovr_2(target, u1, u2, stride, order, points);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Map1f_ovr_0(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; var points: single);
external 'opengl32.dll' name 'glMap1f';
private static procedure z_Map1f_ovr_0_anh0000001(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_Map1f_ovr_0(target, u1, u2, stride, order, points[0]) else
z_Map1f_ovr_0_anh0000001(target, u1, u2, stride, order, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; var points: single) :=
z_Map1f_ovr_0(target, u1, u2, stride, order, points);
private static procedure z_Map1f_ovr_2(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr) :=
z_Map1f_ovr_2(target, u1, u2, stride, order, points);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Map2d_ovr_0(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; var points: real);
external 'opengl32.dll' name 'glMap2d';
private static procedure z_Map2d_ovr_0_anh00000000001(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2d(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: array of real) :=
if (points<>nil) and (points.Length<>0) then
z_Map2d_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]) else
z_Map2d_ovr_0_anh00000000001(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2d(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; var points: real) :=
z_Map2d_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_Map2d_ovr_2(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2d(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr) :=
z_Map2d_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Map2f_ovr_0(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; var points: single);
external 'opengl32.dll' name 'glMap2f';
private static procedure z_Map2f_ovr_0_anh00000000001(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2f(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_Map2f_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]) else
z_Map2f_ovr_0_anh00000000001(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2f(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; var points: single) :=
z_Map2f_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_Map2f_ovr_2(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2f(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr) :=
z_Map2f_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MapGrid1d_ovr_0(un: Int32; u1: real; u2: real);
external 'opengl32.dll' name 'glMapGrid1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1d(un: Int32; u1: real; u2: real) :=
z_MapGrid1d_ovr_0(un, u1, u2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MapGrid1f_ovr_0(un: Int32; u1: single; u2: single);
external 'opengl32.dll' name 'glMapGrid1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1f(un: Int32; u1: single; u2: single) :=
z_MapGrid1f_ovr_0(un, u1, u2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MapGrid2d_ovr_0(un: Int32; u1: real; u2: real; vn: Int32; v1: real; v2: real);
external 'opengl32.dll' name 'glMapGrid2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2d(un: Int32; u1: real; u2: real; vn: Int32; v1: real; v2: real) :=
z_MapGrid2d_ovr_0(un, u1, u2, vn, v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MapGrid2f_ovr_0(un: Int32; u1: single; u2: single; vn: Int32; v1: single; v2: single);
external 'opengl32.dll' name 'glMapGrid2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2f(un: Int32; u1: single; u2: single; vn: Int32; v1: single; v2: single) :=
z_MapGrid2f_ovr_0(un, u1, u2, vn, v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Materialf_ovr_0(face: MaterialFace; pname: MaterialParameter; param: single);
external 'opengl32.dll' name 'glMaterialf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialf(face: MaterialFace; pname: MaterialParameter; param: single) :=
z_Materialf_ovr_0(face, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Materialfv_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glMaterialfv';
private static procedure z_Materialfv_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: MaterialFace; pname: MaterialParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Materialfv_ovr_0(face, pname, ¶ms[0]) else
z_Materialfv_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: MaterialFace; pname: MaterialParameter; var ¶ms: single) :=
z_Materialfv_ovr_0(face, pname, ¶ms);
private static procedure z_Materialfv_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_Materialfv_ovr_2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Materiali_ovr_0(face: MaterialFace; pname: MaterialParameter; param: Int32);
external 'opengl32.dll' name 'glMateriali';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materiali(face: MaterialFace; pname: MaterialParameter; param: Int32) :=
z_Materiali_ovr_0(face, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Materialiv_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glMaterialiv';
private static procedure z_Materialiv_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: MaterialFace; pname: MaterialParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_Materialiv_ovr_0(face, pname, ¶ms[0]) else
z_Materialiv_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32) :=
z_Materialiv_ovr_0(face, pname, ¶ms);
private static procedure z_Materialiv_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_Materialiv_ovr_2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MatrixMode_ovr_0(mode: OpenGL.MatrixMode);
external 'opengl32.dll' name 'glMatrixMode';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMode(mode: OpenGL.MatrixMode) :=
z_MatrixMode_ovr_0(mode);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1d_adr := GetFuncAdr('glMultiTexCoord1d');
private z_MultiTexCoord1d_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real)>(z_MultiTexCoord1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1d(target: TextureUnit; s: real) :=
z_MultiTexCoord1d_ovr_0(target, s);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1dv_adr := GetFuncAdr('glMultiTexCoord1dv');
private z_MultiTexCoord1dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord1dv_adr);
private z_MultiTexCoord1dv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1dv_ovr_0(target, v[0]) else
z_MultiTexCoord1dv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; var v: real) :=
z_MultiTexCoord1dv_ovr_0(target, v);
private z_MultiTexCoord1dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1dv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1f_adr := GetFuncAdr('glMultiTexCoord1f');
private z_MultiTexCoord1f_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single)>(z_MultiTexCoord1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1f(target: TextureUnit; s: single) :=
z_MultiTexCoord1f_ovr_0(target, s);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1fv_adr := GetFuncAdr('glMultiTexCoord1fv');
private z_MultiTexCoord1fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord1fv_adr);
private z_MultiTexCoord1fv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1fv_ovr_0(target, v[0]) else
z_MultiTexCoord1fv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; var v: single) :=
z_MultiTexCoord1fv_ovr_0(target, v);
private z_MultiTexCoord1fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1fv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1i_adr := GetFuncAdr('glMultiTexCoord1i');
private z_MultiTexCoord1i_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32)>(z_MultiTexCoord1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1i(target: TextureUnit; s: Int32) :=
z_MultiTexCoord1i_ovr_0(target, s);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1iv_adr := GetFuncAdr('glMultiTexCoord1iv');
private z_MultiTexCoord1iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord1iv_adr);
private z_MultiTexCoord1iv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1iv_ovr_0(target, v[0]) else
z_MultiTexCoord1iv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord1iv_ovr_0(target, v);
private z_MultiTexCoord1iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1iv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1s_adr := GetFuncAdr('glMultiTexCoord1s');
private z_MultiTexCoord1s_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16)>(z_MultiTexCoord1s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1s(target: TextureUnit; s: Int16) :=
z_MultiTexCoord1s_ovr_0(target, s);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord1sv_adr := GetFuncAdr('glMultiTexCoord1sv');
private z_MultiTexCoord1sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord1sv_adr);
private z_MultiTexCoord1sv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1sv_ovr_0(target, v[0]) else
z_MultiTexCoord1sv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord1sv_ovr_0(target, v);
private z_MultiTexCoord1sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1sv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2d_adr := GetFuncAdr('glMultiTexCoord2d');
private z_MultiTexCoord2d_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real)>(z_MultiTexCoord2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2d(target: TextureUnit; s: real; t: real) :=
z_MultiTexCoord2d_ovr_0(target, s, t);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2dv_adr := GetFuncAdr('glMultiTexCoord2dv');
private z_MultiTexCoord2dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord2dv_adr);
private z_MultiTexCoord2dv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2dv_ovr_0(target, v[0]) else
z_MultiTexCoord2dv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; var v: real) :=
z_MultiTexCoord2dv_ovr_0(target, v);
private z_MultiTexCoord2dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2dv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2f_adr := GetFuncAdr('glMultiTexCoord2f');
private z_MultiTexCoord2f_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single)>(z_MultiTexCoord2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2f(target: TextureUnit; s: single; t: single) :=
z_MultiTexCoord2f_ovr_0(target, s, t);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2fv_adr := GetFuncAdr('glMultiTexCoord2fv');
private z_MultiTexCoord2fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord2fv_adr);
private z_MultiTexCoord2fv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2fv_ovr_0(target, v[0]) else
z_MultiTexCoord2fv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; var v: single) :=
z_MultiTexCoord2fv_ovr_0(target, v);
private z_MultiTexCoord2fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2fv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2i_adr := GetFuncAdr('glMultiTexCoord2i');
private z_MultiTexCoord2i_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32)>(z_MultiTexCoord2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2i(target: TextureUnit; s: Int32; t: Int32) :=
z_MultiTexCoord2i_ovr_0(target, s, t);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2iv_adr := GetFuncAdr('glMultiTexCoord2iv');
private z_MultiTexCoord2iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord2iv_adr);
private z_MultiTexCoord2iv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2iv_ovr_0(target, v[0]) else
z_MultiTexCoord2iv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord2iv_ovr_0(target, v);
private z_MultiTexCoord2iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2iv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2s_adr := GetFuncAdr('glMultiTexCoord2s');
private z_MultiTexCoord2s_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16)>(z_MultiTexCoord2s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2s(target: TextureUnit; s: Int16; t: Int16) :=
z_MultiTexCoord2s_ovr_0(target, s, t);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord2sv_adr := GetFuncAdr('glMultiTexCoord2sv');
private z_MultiTexCoord2sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord2sv_adr);
private z_MultiTexCoord2sv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2sv_ovr_0(target, v[0]) else
z_MultiTexCoord2sv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord2sv_ovr_0(target, v);
private z_MultiTexCoord2sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2sv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3d_adr := GetFuncAdr('glMultiTexCoord3d');
private z_MultiTexCoord3d_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real; r: real)>(z_MultiTexCoord3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3d(target: TextureUnit; s: real; t: real; r: real) :=
z_MultiTexCoord3d_ovr_0(target, s, t, r);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3dv_adr := GetFuncAdr('glMultiTexCoord3dv');
private z_MultiTexCoord3dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord3dv_adr);
private z_MultiTexCoord3dv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3dv_ovr_0(target, v[0]) else
z_MultiTexCoord3dv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; var v: real) :=
z_MultiTexCoord3dv_ovr_0(target, v);
private z_MultiTexCoord3dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3dv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3f_adr := GetFuncAdr('glMultiTexCoord3f');
private z_MultiTexCoord3f_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single; r: single)>(z_MultiTexCoord3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3f(target: TextureUnit; s: single; t: single; r: single) :=
z_MultiTexCoord3f_ovr_0(target, s, t, r);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3fv_adr := GetFuncAdr('glMultiTexCoord3fv');
private z_MultiTexCoord3fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord3fv_adr);
private z_MultiTexCoord3fv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3fv_ovr_0(target, v[0]) else
z_MultiTexCoord3fv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; var v: single) :=
z_MultiTexCoord3fv_ovr_0(target, v);
private z_MultiTexCoord3fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3fv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3i_adr := GetFuncAdr('glMultiTexCoord3i');
private z_MultiTexCoord3i_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32; r: Int32)>(z_MultiTexCoord3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3i(target: TextureUnit; s: Int32; t: Int32; r: Int32) :=
z_MultiTexCoord3i_ovr_0(target, s, t, r);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3iv_adr := GetFuncAdr('glMultiTexCoord3iv');
private z_MultiTexCoord3iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord3iv_adr);
private z_MultiTexCoord3iv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3iv_ovr_0(target, v[0]) else
z_MultiTexCoord3iv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord3iv_ovr_0(target, v);
private z_MultiTexCoord3iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3iv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3s_adr := GetFuncAdr('glMultiTexCoord3s');
private z_MultiTexCoord3s_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16; r: Int16)>(z_MultiTexCoord3s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3s(target: TextureUnit; s: Int16; t: Int16; r: Int16) :=
z_MultiTexCoord3s_ovr_0(target, s, t, r);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord3sv_adr := GetFuncAdr('glMultiTexCoord3sv');
private z_MultiTexCoord3sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord3sv_adr);
private z_MultiTexCoord3sv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3sv_ovr_0(target, v[0]) else
z_MultiTexCoord3sv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord3sv_ovr_0(target, v);
private z_MultiTexCoord3sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3sv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4d_adr := GetFuncAdr('glMultiTexCoord4d');
private z_MultiTexCoord4d_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real; r: real; q: real)>(z_MultiTexCoord4d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4d(target: TextureUnit; s: real; t: real; r: real; q: real) :=
z_MultiTexCoord4d_ovr_0(target, s, t, r, q);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4dv_adr := GetFuncAdr('glMultiTexCoord4dv');
private z_MultiTexCoord4dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord4dv_adr);
private z_MultiTexCoord4dv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4dv_ovr_0(target, v[0]) else
z_MultiTexCoord4dv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; var v: real) :=
z_MultiTexCoord4dv_ovr_0(target, v);
private z_MultiTexCoord4dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4dv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4f_adr := GetFuncAdr('glMultiTexCoord4f');
private z_MultiTexCoord4f_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single; r: single; q: single)>(z_MultiTexCoord4f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4f(target: TextureUnit; s: single; t: single; r: single; q: single) :=
z_MultiTexCoord4f_ovr_0(target, s, t, r, q);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4fv_adr := GetFuncAdr('glMultiTexCoord4fv');
private z_MultiTexCoord4fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord4fv_adr);
private z_MultiTexCoord4fv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4fv_ovr_0(target, v[0]) else
z_MultiTexCoord4fv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; var v: single) :=
z_MultiTexCoord4fv_ovr_0(target, v);
private z_MultiTexCoord4fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4fv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4i_adr := GetFuncAdr('glMultiTexCoord4i');
private z_MultiTexCoord4i_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32)>(z_MultiTexCoord4i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4i(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32) :=
z_MultiTexCoord4i_ovr_0(target, s, t, r, q);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4iv_adr := GetFuncAdr('glMultiTexCoord4iv');
private z_MultiTexCoord4iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord4iv_adr);
private z_MultiTexCoord4iv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4iv_ovr_0(target, v[0]) else
z_MultiTexCoord4iv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord4iv_ovr_0(target, v);
private z_MultiTexCoord4iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4iv_ovr_2(target, v);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4s_adr := GetFuncAdr('glMultiTexCoord4s');
private z_MultiTexCoord4s_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16)>(z_MultiTexCoord4s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4s(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16) :=
z_MultiTexCoord4s_ovr_0(target, s, t, r, q);
// added in gl1.3, deprecated in gl3.2
private z_MultiTexCoord4sv_adr := GetFuncAdr('glMultiTexCoord4sv');
private z_MultiTexCoord4sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord4sv_adr);
private z_MultiTexCoord4sv_ovr_0_anh001 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4sv_ovr_0(target, v[0]) else
z_MultiTexCoord4sv_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord4sv_ovr_0(target, v);
private z_MultiTexCoord4sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4sv_ovr_2(target, v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MultMatrixd_ovr_0(var m: real);
external 'opengl32.dll' name 'glMultMatrixd';
private static procedure z_MultMatrixd_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MultMatrixd_ovr_0(m[0]) else
z_MultMatrixd_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(var m: real) :=
z_MultMatrixd_ovr_0(m);
private static procedure z_MultMatrixd_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(m: IntPtr) :=
z_MultMatrixd_ovr_2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure z_MultMatrixf_ovr_0(var m: single);
external 'opengl32.dll' name 'glMultMatrixf';
private static procedure z_MultMatrixf_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MultMatrixf_ovr_0(m[0]) else
z_MultMatrixf_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(var m: single) :=
z_MultMatrixf_ovr_0(m);
private static procedure z_MultMatrixf_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(m: IntPtr) :=
z_MultMatrixf_ovr_2(m);
// added in gl1.3, deprecated in gl3.2
private z_MultTransposeMatrixd_adr := GetFuncAdr('glMultTransposeMatrixd');
private z_MultTransposeMatrixd_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_MultTransposeMatrixd_adr);
private z_MultTransposeMatrixd_ovr_0_anh01 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MultTransposeMatrixd_ovr_0(m[0]) else
z_MultTransposeMatrixd_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(var m: real) :=
z_MultTransposeMatrixd_ovr_0(m);
private z_MultTransposeMatrixd_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(m: IntPtr) :=
z_MultTransposeMatrixd_ovr_2(m);
// added in gl1.3, deprecated in gl3.2
private z_MultTransposeMatrixf_adr := GetFuncAdr('glMultTransposeMatrixf');
private z_MultTransposeMatrixf_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_MultTransposeMatrixf_adr);
private z_MultTransposeMatrixf_ovr_0_anh01 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MultTransposeMatrixf_ovr_0(m[0]) else
z_MultTransposeMatrixf_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(var m: single) :=
z_MultTransposeMatrixf_ovr_0(m);
private z_MultTransposeMatrixf_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(m: IntPtr) :=
z_MultTransposeMatrixf_ovr_2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure z_NewList_ovr_0(list: UInt32; mode: ListMode);
external 'opengl32.dll' name 'glNewList';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NewList(list: UInt32; mode: ListMode) :=
z_NewList_ovr_0(list, mode);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3b_ovr_0(nx: SByte; ny: SByte; nz: SByte);
external 'opengl32.dll' name 'glNormal3b';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3b(nx: SByte; ny: SByte; nz: SByte) :=
z_Normal3b_ovr_0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3bv_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glNormal3bv';
private static procedure z_Normal3bv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3bv_ovr_0(v[0]) else
z_Normal3bv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(var v: SByte) :=
z_Normal3bv_ovr_0(v);
private static procedure z_Normal3bv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3bv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(v: IntPtr) :=
z_Normal3bv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3d_ovr_0(nx: real; ny: real; nz: real);
external 'opengl32.dll' name 'glNormal3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3d(nx: real; ny: real; nz: real) :=
z_Normal3d_ovr_0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glNormal3dv';
private static procedure z_Normal3dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3dv_ovr_0(v[0]) else
z_Normal3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(var v: real) :=
z_Normal3dv_ovr_0(v);
private static procedure z_Normal3dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(v: IntPtr) :=
z_Normal3dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3f_ovr_0(nx: single; ny: single; nz: single);
external 'opengl32.dll' name 'glNormal3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3f(nx: single; ny: single; nz: single) :=
z_Normal3f_ovr_0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glNormal3fv';
private static procedure z_Normal3fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3fv_ovr_0(v[0]) else
z_Normal3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(var v: single) :=
z_Normal3fv_ovr_0(v);
private static procedure z_Normal3fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(v: IntPtr) :=
z_Normal3fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3i_ovr_0(nx: Int32; ny: Int32; nz: Int32);
external 'opengl32.dll' name 'glNormal3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3i(nx: Int32; ny: Int32; nz: Int32) :=
z_Normal3i_ovr_0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glNormal3iv';
private static procedure z_Normal3iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3iv_ovr_0(v[0]) else
z_Normal3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(var v: Int32) :=
z_Normal3iv_ovr_0(v);
private static procedure z_Normal3iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(v: IntPtr) :=
z_Normal3iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3s_ovr_0(nx: Int16; ny: Int16; nz: Int16);
external 'opengl32.dll' name 'glNormal3s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3s(nx: Int16; ny: Int16; nz: Int16) :=
z_Normal3s_ovr_0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Normal3sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glNormal3sv';
private static procedure z_Normal3sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3sv_ovr_0(v[0]) else
z_Normal3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(var v: Int16) :=
z_Normal3sv_ovr_0(v);
private static procedure z_Normal3sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(v: IntPtr) :=
z_Normal3sv_ovr_2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure z_NormalPointer_ovr_0(&type: NormalPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glNormalPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointer(&type: NormalPointerType; stride: Int32; pointer: IntPtr) :=
z_NormalPointer_ovr_0(&type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Ortho_ovr_0(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glOrtho';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Ortho(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_Ortho_ovr_0(left, right, bottom, top, zNear, zFar);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PassThrough_ovr_0(token: single);
external 'opengl32.dll' name 'glPassThrough';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassThrough(token: single) :=
z_PassThrough_ovr_0(token);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelMapfv_ovr_0(map: PixelMap; mapsize: Int32; var values: single);
external 'opengl32.dll' name 'glPixelMapfv';
private static procedure z_PixelMapfv_ovr_0_anh0001(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_PixelMapfv_ovr_0(map, mapsize, values[0]) else
z_PixelMapfv_ovr_0_anh0001(map, mapsize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; var values: single) :=
z_PixelMapfv_ovr_0(map, mapsize, values);
private static procedure z_PixelMapfv_ovr_2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; values: IntPtr) :=
z_PixelMapfv_ovr_2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelMapuiv_ovr_0(map: PixelMap; mapsize: Int32; var values: UInt32);
external 'opengl32.dll' name 'glPixelMapuiv';
private static procedure z_PixelMapuiv_ovr_0_anh0001(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; values: array of UInt32) :=
if (values<>nil) and (values.Length<>0) then
z_PixelMapuiv_ovr_0(map, mapsize, values[0]) else
z_PixelMapuiv_ovr_0_anh0001(map, mapsize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; var values: UInt32) :=
z_PixelMapuiv_ovr_0(map, mapsize, values);
private static procedure z_PixelMapuiv_ovr_2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; values: IntPtr) :=
z_PixelMapuiv_ovr_2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelMapusv_ovr_0(map: PixelMap; mapsize: Int32; var values: UInt16);
external 'opengl32.dll' name 'glPixelMapusv';
private static procedure z_PixelMapusv_ovr_0_anh0001(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapusv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; values: array of UInt16) :=
if (values<>nil) and (values.Length<>0) then
z_PixelMapusv_ovr_0(map, mapsize, values[0]) else
z_PixelMapusv_ovr_0_anh0001(map, mapsize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; var values: UInt16) :=
z_PixelMapusv_ovr_0(map, mapsize, values);
private static procedure z_PixelMapusv_ovr_2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapusv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; values: IntPtr) :=
z_PixelMapusv_ovr_2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelTransferf_ovr_0(pname: PixelTransferParameter; param: single);
external 'opengl32.dll' name 'glPixelTransferf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferf(pname: PixelTransferParameter; param: single) :=
z_PixelTransferf_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelTransferi_ovr_0(pname: PixelTransferParameter; param: Int32);
external 'opengl32.dll' name 'glPixelTransferi';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferi(pname: PixelTransferParameter; param: Int32) :=
z_PixelTransferi_ovr_0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PixelZoom_ovr_0(xfactor: single; yfactor: single);
external 'opengl32.dll' name 'glPixelZoom';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelZoom(xfactor: single; yfactor: single) :=
z_PixelZoom_ovr_0(xfactor, yfactor);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PolygonStipple_ovr_0(var mask: Byte);
external 'opengl32.dll' name 'glPolygonStipple';
private static procedure z_PolygonStipple_ovr_0_anh01(mask: IntPtr);
external 'opengl32.dll' name 'glPolygonStipple';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(mask: array of Byte) :=
if (mask<>nil) and (mask.Length<>0) then
z_PolygonStipple_ovr_0(mask[0]) else
z_PolygonStipple_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(var mask: Byte) :=
z_PolygonStipple_ovr_0(mask);
private static procedure z_PolygonStipple_ovr_2(mask: IntPtr);
external 'opengl32.dll' name 'glPolygonStipple';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(mask: IntPtr) :=
z_PolygonStipple_ovr_2(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PopAttrib_ovr_0;
external 'opengl32.dll' name 'glPopAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopAttrib :=
z_PopAttrib_ovr_0;
// added in gl1.1, deprecated in gl3.2
private static procedure z_PopClientAttrib_ovr_0;
external 'opengl32.dll' name 'glPopClientAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopClientAttrib :=
z_PopClientAttrib_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_PopMatrix_ovr_0;
external 'opengl32.dll' name 'glPopMatrix';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopMatrix :=
z_PopMatrix_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_PopName_ovr_0;
external 'opengl32.dll' name 'glPopName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopName :=
z_PopName_ovr_0;
// added in gl1.1, deprecated in gl3.2
private static procedure z_PrioritizeTextures_ovr_0(n: Int32; var textures: UInt32; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
private static procedure z_PrioritizeTextures_ovr_0_anh0010(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
private static procedure z_PrioritizeTextures_ovr_0_anh0001(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
private static procedure z_PrioritizeTextures_ovr_0_anh0011(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; priorities: array of single) :=
if (textures<>nil) and (textures.Length<>0) then
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTextures_ovr_0(n, textures[0], priorities[0]) else
z_PrioritizeTextures_ovr_0_anh0001(n, textures[0], IntPtr.Zero) else
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTextures_ovr_0_anh0010(n, IntPtr.Zero, priorities[0]) else
z_PrioritizeTextures_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static procedure z_PrioritizeTextures_ovr_1_anh0010(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; var priorities: single) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTextures_ovr_0(n, textures[0], priorities) else
z_PrioritizeTextures_ovr_0_anh0010(n, IntPtr.Zero, priorities);
private static procedure z_PrioritizeTextures_ovr_2(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
private static procedure z_PrioritizeTextures_ovr_2_anh0010(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; priorities: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTextures_ovr_2(n, textures[0], priorities) else
z_PrioritizeTextures_ovr_2_anh0010(n, IntPtr.Zero, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; priorities: array of single) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTextures_ovr_0(n, textures, priorities[0]) else
z_PrioritizeTextures_ovr_0_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; var priorities: single) :=
z_PrioritizeTextures_ovr_0(n, textures, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; priorities: IntPtr) :=
z_PrioritizeTextures_ovr_2(n, textures, priorities);
private static procedure z_PrioritizeTextures_ovr_6(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
private static procedure z_PrioritizeTextures_ovr_6_anh0001(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; priorities: array of single) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTextures_ovr_6(n, textures, priorities[0]) else
z_PrioritizeTextures_ovr_6_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; var priorities: single) :=
z_PrioritizeTextures_ovr_6(n, textures, priorities);
private static procedure z_PrioritizeTextures_ovr_8(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; priorities: IntPtr) :=
z_PrioritizeTextures_ovr_8(n, textures, priorities);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PushAttrib_ovr_0(mask: AttribMask);
external 'opengl32.dll' name 'glPushAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushAttrib(mask: AttribMask) :=
z_PushAttrib_ovr_0(mask);
// added in gl1.1, deprecated in gl3.2
private static procedure z_PushClientAttrib_ovr_0(mask: ClientAttribMask);
external 'opengl32.dll' name 'glPushClientAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushClientAttrib(mask: ClientAttribMask) :=
z_PushClientAttrib_ovr_0(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure z_PushMatrix_ovr_0;
external 'opengl32.dll' name 'glPushMatrix';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushMatrix :=
z_PushMatrix_ovr_0;
// added in gl1.0, deprecated in gl3.2
private static procedure z_PushName_ovr_0(name: UInt32);
external 'opengl32.dll' name 'glPushName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushName(name: UInt32) :=
z_PushName_ovr_0(name);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2d_ovr_0(x: real; y: real);
external 'opengl32.dll' name 'glRasterPos2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2d(x: real; y: real) :=
z_RasterPos2d_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glRasterPos2dv';
private static procedure z_RasterPos2dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos2dv_ovr_0(v[0]) else
z_RasterPos2dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(var v: real) :=
z_RasterPos2dv_ovr_0(v);
private static procedure z_RasterPos2dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(v: IntPtr) :=
z_RasterPos2dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2f_ovr_0(x: single; y: single);
external 'opengl32.dll' name 'glRasterPos2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2f(x: single; y: single) :=
z_RasterPos2f_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glRasterPos2fv';
private static procedure z_RasterPos2fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos2fv_ovr_0(v[0]) else
z_RasterPos2fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(var v: single) :=
z_RasterPos2fv_ovr_0(v);
private static procedure z_RasterPos2fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(v: IntPtr) :=
z_RasterPos2fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2i_ovr_0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glRasterPos2i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2i(x: Int32; y: Int32) :=
z_RasterPos2i_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glRasterPos2iv';
private static procedure z_RasterPos2iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos2iv_ovr_0(v[0]) else
z_RasterPos2iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(var v: Int32) :=
z_RasterPos2iv_ovr_0(v);
private static procedure z_RasterPos2iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(v: IntPtr) :=
z_RasterPos2iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2s_ovr_0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glRasterPos2s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2s(x: Int16; y: Int16) :=
z_RasterPos2s_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos2sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glRasterPos2sv';
private static procedure z_RasterPos2sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos2sv_ovr_0(v[0]) else
z_RasterPos2sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(var v: Int16) :=
z_RasterPos2sv_ovr_0(v);
private static procedure z_RasterPos2sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(v: IntPtr) :=
z_RasterPos2sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3d_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glRasterPos3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3d(x: real; y: real; z: real) :=
z_RasterPos3d_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glRasterPos3dv';
private static procedure z_RasterPos3dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos3dv_ovr_0(v[0]) else
z_RasterPos3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(var v: real) :=
z_RasterPos3dv_ovr_0(v);
private static procedure z_RasterPos3dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(v: IntPtr) :=
z_RasterPos3dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3f_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glRasterPos3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3f(x: single; y: single; z: single) :=
z_RasterPos3f_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glRasterPos3fv';
private static procedure z_RasterPos3fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos3fv_ovr_0(v[0]) else
z_RasterPos3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(var v: single) :=
z_RasterPos3fv_ovr_0(v);
private static procedure z_RasterPos3fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(v: IntPtr) :=
z_RasterPos3fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3i_ovr_0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glRasterPos3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3i(x: Int32; y: Int32; z: Int32) :=
z_RasterPos3i_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glRasterPos3iv';
private static procedure z_RasterPos3iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos3iv_ovr_0(v[0]) else
z_RasterPos3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(var v: Int32) :=
z_RasterPos3iv_ovr_0(v);
private static procedure z_RasterPos3iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(v: IntPtr) :=
z_RasterPos3iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3s_ovr_0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glRasterPos3s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3s(x: Int16; y: Int16; z: Int16) :=
z_RasterPos3s_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos3sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glRasterPos3sv';
private static procedure z_RasterPos3sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos3sv_ovr_0(v[0]) else
z_RasterPos3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(var v: Int16) :=
z_RasterPos3sv_ovr_0(v);
private static procedure z_RasterPos3sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(v: IntPtr) :=
z_RasterPos3sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4d_ovr_0(x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glRasterPos4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4d(x: real; y: real; z: real; w: real) :=
z_RasterPos4d_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glRasterPos4dv';
private static procedure z_RasterPos4dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos4dv_ovr_0(v[0]) else
z_RasterPos4dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(var v: real) :=
z_RasterPos4dv_ovr_0(v);
private static procedure z_RasterPos4dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(v: IntPtr) :=
z_RasterPos4dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4f_ovr_0(x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glRasterPos4f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4f(x: single; y: single; z: single; w: single) :=
z_RasterPos4f_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glRasterPos4fv';
private static procedure z_RasterPos4fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos4fv_ovr_0(v[0]) else
z_RasterPos4fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(var v: single) :=
z_RasterPos4fv_ovr_0(v);
private static procedure z_RasterPos4fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(v: IntPtr) :=
z_RasterPos4fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4i_ovr_0(x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glRasterPos4i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4i(x: Int32; y: Int32; z: Int32; w: Int32) :=
z_RasterPos4i_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glRasterPos4iv';
private static procedure z_RasterPos4iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos4iv_ovr_0(v[0]) else
z_RasterPos4iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(var v: Int32) :=
z_RasterPos4iv_ovr_0(v);
private static procedure z_RasterPos4iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(v: IntPtr) :=
z_RasterPos4iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4s_ovr_0(x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glRasterPos4s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4s(x: Int16; y: Int16; z: Int16; w: Int16) :=
z_RasterPos4s_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_RasterPos4sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glRasterPos4sv';
private static procedure z_RasterPos4sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_RasterPos4sv_ovr_0(v[0]) else
z_RasterPos4sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(var v: Int16) :=
z_RasterPos4sv_ovr_0(v);
private static procedure z_RasterPos4sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(v: IntPtr) :=
z_RasterPos4sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectd_ovr_0(x1: real; y1: real; x2: real; y2: real);
external 'opengl32.dll' name 'glRectd';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectd(x1: real; y1: real; x2: real; y2: real) :=
z_Rectd_ovr_0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectdv_ovr_0(var v1: real; var v2: real);
external 'opengl32.dll' name 'glRectdv';
private static procedure z_Rectdv_ovr_0_anh010(v1: IntPtr; var v2: real);
external 'opengl32.dll' name 'glRectdv';
private static procedure z_Rectdv_ovr_0_anh001(var v1: real; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
private static procedure z_Rectdv_ovr_0_anh011(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; v2: array of real) :=
if (v1<>nil) and (v1.Length<>0) then
if (v2<>nil) and (v2.Length<>0) then
z_Rectdv_ovr_0(v1[0], v2[0]) else
z_Rectdv_ovr_0_anh001(v1[0], IntPtr.Zero) else
if (v2<>nil) and (v2.Length<>0) then
z_Rectdv_ovr_0_anh010(IntPtr.Zero, v2[0]) else
z_Rectdv_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static procedure z_Rectdv_ovr_1_anh010(v1: IntPtr; var v2: real);
external 'opengl32.dll' name 'glRectdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; var v2: real) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectdv_ovr_0(v1[0], v2) else
z_Rectdv_ovr_0_anh010(IntPtr.Zero, v2);
private static procedure z_Rectdv_ovr_2(var v1: real; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
private static procedure z_Rectdv_ovr_2_anh010(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; v2: IntPtr) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectdv_ovr_2(v1[0], v2) else
z_Rectdv_ovr_2_anh010(IntPtr.Zero, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; v2: array of real) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectdv_ovr_0(v1, v2[0]) else
z_Rectdv_ovr_0_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; var v2: real) :=
z_Rectdv_ovr_0(v1, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; v2: IntPtr) :=
z_Rectdv_ovr_2(v1, v2);
private static procedure z_Rectdv_ovr_6(v1: IntPtr; var v2: real);
external 'opengl32.dll' name 'glRectdv';
private static procedure z_Rectdv_ovr_6_anh001(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; v2: array of real) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectdv_ovr_6(v1, v2[0]) else
z_Rectdv_ovr_6_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; var v2: real) :=
z_Rectdv_ovr_6(v1, v2);
private static procedure z_Rectdv_ovr_8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; v2: IntPtr) :=
z_Rectdv_ovr_8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectf_ovr_0(x1: single; y1: single; x2: single; y2: single);
external 'opengl32.dll' name 'glRectf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectf(x1: single; y1: single; x2: single; y2: single) :=
z_Rectf_ovr_0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectfv_ovr_0(var v1: single; var v2: single);
external 'opengl32.dll' name 'glRectfv';
private static procedure z_Rectfv_ovr_0_anh010(v1: IntPtr; var v2: single);
external 'opengl32.dll' name 'glRectfv';
private static procedure z_Rectfv_ovr_0_anh001(var v1: single; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
private static procedure z_Rectfv_ovr_0_anh011(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; v2: array of single) :=
if (v1<>nil) and (v1.Length<>0) then
if (v2<>nil) and (v2.Length<>0) then
z_Rectfv_ovr_0(v1[0], v2[0]) else
z_Rectfv_ovr_0_anh001(v1[0], IntPtr.Zero) else
if (v2<>nil) and (v2.Length<>0) then
z_Rectfv_ovr_0_anh010(IntPtr.Zero, v2[0]) else
z_Rectfv_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static procedure z_Rectfv_ovr_1_anh010(v1: IntPtr; var v2: single);
external 'opengl32.dll' name 'glRectfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; var v2: single) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectfv_ovr_0(v1[0], v2) else
z_Rectfv_ovr_0_anh010(IntPtr.Zero, v2);
private static procedure z_Rectfv_ovr_2(var v1: single; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
private static procedure z_Rectfv_ovr_2_anh010(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; v2: IntPtr) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectfv_ovr_2(v1[0], v2) else
z_Rectfv_ovr_2_anh010(IntPtr.Zero, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; v2: array of single) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectfv_ovr_0(v1, v2[0]) else
z_Rectfv_ovr_0_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; var v2: single) :=
z_Rectfv_ovr_0(v1, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; v2: IntPtr) :=
z_Rectfv_ovr_2(v1, v2);
private static procedure z_Rectfv_ovr_6(v1: IntPtr; var v2: single);
external 'opengl32.dll' name 'glRectfv';
private static procedure z_Rectfv_ovr_6_anh001(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; v2: array of single) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectfv_ovr_6(v1, v2[0]) else
z_Rectfv_ovr_6_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; var v2: single) :=
z_Rectfv_ovr_6(v1, v2);
private static procedure z_Rectfv_ovr_8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; v2: IntPtr) :=
z_Rectfv_ovr_8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Recti_ovr_0(x1: Int32; y1: Int32; x2: Int32; y2: Int32);
external 'opengl32.dll' name 'glRecti';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Recti(x1: Int32; y1: Int32; x2: Int32; y2: Int32) :=
z_Recti_ovr_0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectiv_ovr_0(var v1: Int32; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
private static procedure z_Rectiv_ovr_0_anh010(v1: IntPtr; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
private static procedure z_Rectiv_ovr_0_anh001(var v1: Int32; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
private static procedure z_Rectiv_ovr_0_anh011(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; v2: array of Int32) :=
if (v1<>nil) and (v1.Length<>0) then
if (v2<>nil) and (v2.Length<>0) then
z_Rectiv_ovr_0(v1[0], v2[0]) else
z_Rectiv_ovr_0_anh001(v1[0], IntPtr.Zero) else
if (v2<>nil) and (v2.Length<>0) then
z_Rectiv_ovr_0_anh010(IntPtr.Zero, v2[0]) else
z_Rectiv_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static procedure z_Rectiv_ovr_1_anh010(v1: IntPtr; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; var v2: Int32) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectiv_ovr_0(v1[0], v2) else
z_Rectiv_ovr_0_anh010(IntPtr.Zero, v2);
private static procedure z_Rectiv_ovr_2(var v1: Int32; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
private static procedure z_Rectiv_ovr_2_anh010(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; v2: IntPtr) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectiv_ovr_2(v1[0], v2) else
z_Rectiv_ovr_2_anh010(IntPtr.Zero, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; v2: array of Int32) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectiv_ovr_0(v1, v2[0]) else
z_Rectiv_ovr_0_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; var v2: Int32) :=
z_Rectiv_ovr_0(v1, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; v2: IntPtr) :=
z_Rectiv_ovr_2(v1, v2);
private static procedure z_Rectiv_ovr_6(v1: IntPtr; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
private static procedure z_Rectiv_ovr_6_anh001(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; v2: array of Int32) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectiv_ovr_6(v1, v2[0]) else
z_Rectiv_ovr_6_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; var v2: Int32) :=
z_Rectiv_ovr_6(v1, v2);
private static procedure z_Rectiv_ovr_8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; v2: IntPtr) :=
z_Rectiv_ovr_8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rects_ovr_0(x1: Int16; y1: Int16; x2: Int16; y2: Int16);
external 'opengl32.dll' name 'glRects';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rects(x1: Int16; y1: Int16; x2: Int16; y2: Int16) :=
z_Rects_ovr_0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rectsv_ovr_0(var v1: Int16; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
private static procedure z_Rectsv_ovr_0_anh010(v1: IntPtr; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
private static procedure z_Rectsv_ovr_0_anh001(var v1: Int16; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
private static procedure z_Rectsv_ovr_0_anh011(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; v2: array of Int16) :=
if (v1<>nil) and (v1.Length<>0) then
if (v2<>nil) and (v2.Length<>0) then
z_Rectsv_ovr_0(v1[0], v2[0]) else
z_Rectsv_ovr_0_anh001(v1[0], IntPtr.Zero) else
if (v2<>nil) and (v2.Length<>0) then
z_Rectsv_ovr_0_anh010(IntPtr.Zero, v2[0]) else
z_Rectsv_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static procedure z_Rectsv_ovr_1_anh010(v1: IntPtr; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; var v2: Int16) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectsv_ovr_0(v1[0], v2) else
z_Rectsv_ovr_0_anh010(IntPtr.Zero, v2);
private static procedure z_Rectsv_ovr_2(var v1: Int16; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
private static procedure z_Rectsv_ovr_2_anh010(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; v2: IntPtr) :=
if (v1<>nil) and (v1.Length<>0) then
z_Rectsv_ovr_2(v1[0], v2) else
z_Rectsv_ovr_2_anh010(IntPtr.Zero, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; v2: array of Int16) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectsv_ovr_0(v1, v2[0]) else
z_Rectsv_ovr_0_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; var v2: Int16) :=
z_Rectsv_ovr_0(v1, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; v2: IntPtr) :=
z_Rectsv_ovr_2(v1, v2);
private static procedure z_Rectsv_ovr_6(v1: IntPtr; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
private static procedure z_Rectsv_ovr_6_anh001(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; v2: array of Int16) :=
if (v2<>nil) and (v2.Length<>0) then
z_Rectsv_ovr_6(v1, v2[0]) else
z_Rectsv_ovr_6_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; var v2: Int16) :=
z_Rectsv_ovr_6(v1, v2);
private static procedure z_Rectsv_ovr_8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; v2: IntPtr) :=
z_Rectsv_ovr_8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static function z_RenderMode_ovr_0(mode: RenderingMode): Int32;
external 'opengl32.dll' name 'glRenderMode';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function RenderMode(mode: RenderingMode): Int32 :=
z_RenderMode_ovr_0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rotated_ovr_0(angle: real; x: real; y: real; z: real);
external 'opengl32.dll' name 'glRotated';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rotated(angle: real; x: real; y: real; z: real) :=
z_Rotated_ovr_0(angle, x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Rotatef_ovr_0(angle: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glRotatef';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rotatef(angle: single; x: single; y: single; z: single) :=
z_Rotatef_ovr_0(angle, x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Scaled_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glScaled';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scaled(x: real; y: real; z: real) :=
z_Scaled_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Scalef_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glScalef';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scalef(x: single; y: single; z: single) :=
z_Scalef_ovr_0(x, y, z);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3b_adr := GetFuncAdr('glSecondaryColor3b');
private z_SecondaryColor3b_ovr_0 := GetFuncOrNil&<procedure(red: SByte; green: SByte; blue: SByte)>(z_SecondaryColor3b_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3b(red: SByte; green: SByte; blue: SByte) :=
z_SecondaryColor3b_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3bv_adr := GetFuncAdr('glSecondaryColor3bv');
private z_SecondaryColor3bv_ovr_0 := GetFuncOrNil&<procedure(var v: SByte)>(z_SecondaryColor3bv_adr);
private z_SecondaryColor3bv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3bv_ovr_0(v[0]) else
z_SecondaryColor3bv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(var v: SByte) :=
z_SecondaryColor3bv_ovr_0(v);
private z_SecondaryColor3bv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(v: IntPtr) :=
z_SecondaryColor3bv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3d_adr := GetFuncAdr('glSecondaryColor3d');
private z_SecondaryColor3d_ovr_0 := GetFuncOrNil&<procedure(red: real; green: real; blue: real)>(z_SecondaryColor3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3d(red: real; green: real; blue: real) :=
z_SecondaryColor3d_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3dv_adr := GetFuncAdr('glSecondaryColor3dv');
private z_SecondaryColor3dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_SecondaryColor3dv_adr);
private z_SecondaryColor3dv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3dv_ovr_0(v[0]) else
z_SecondaryColor3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(var v: real) :=
z_SecondaryColor3dv_ovr_0(v);
private z_SecondaryColor3dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(v: IntPtr) :=
z_SecondaryColor3dv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3f_adr := GetFuncAdr('glSecondaryColor3f');
private z_SecondaryColor3f_ovr_0 := GetFuncOrNil&<procedure(red: single; green: single; blue: single)>(z_SecondaryColor3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3f(red: single; green: single; blue: single) :=
z_SecondaryColor3f_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3fv_adr := GetFuncAdr('glSecondaryColor3fv');
private z_SecondaryColor3fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_SecondaryColor3fv_adr);
private z_SecondaryColor3fv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3fv_ovr_0(v[0]) else
z_SecondaryColor3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(var v: single) :=
z_SecondaryColor3fv_ovr_0(v);
private z_SecondaryColor3fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(v: IntPtr) :=
z_SecondaryColor3fv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3i_adr := GetFuncAdr('glSecondaryColor3i');
private z_SecondaryColor3i_ovr_0 := GetFuncOrNil&<procedure(red: Int32; green: Int32; blue: Int32)>(z_SecondaryColor3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3i(red: Int32; green: Int32; blue: Int32) :=
z_SecondaryColor3i_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3iv_adr := GetFuncAdr('glSecondaryColor3iv');
private z_SecondaryColor3iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_SecondaryColor3iv_adr);
private z_SecondaryColor3iv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3iv_ovr_0(v[0]) else
z_SecondaryColor3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(var v: Int32) :=
z_SecondaryColor3iv_ovr_0(v);
private z_SecondaryColor3iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(v: IntPtr) :=
z_SecondaryColor3iv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3s_adr := GetFuncAdr('glSecondaryColor3s');
private z_SecondaryColor3s_ovr_0 := GetFuncOrNil&<procedure(red: Int16; green: Int16; blue: Int16)>(z_SecondaryColor3s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3s(red: Int16; green: Int16; blue: Int16) :=
z_SecondaryColor3s_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3sv_adr := GetFuncAdr('glSecondaryColor3sv');
private z_SecondaryColor3sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_SecondaryColor3sv_adr);
private z_SecondaryColor3sv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3sv_ovr_0(v[0]) else
z_SecondaryColor3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(var v: Int16) :=
z_SecondaryColor3sv_ovr_0(v);
private z_SecondaryColor3sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(v: IntPtr) :=
z_SecondaryColor3sv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3ub_adr := GetFuncAdr('glSecondaryColor3ub');
private z_SecondaryColor3ub_ovr_0 := GetFuncOrNil&<procedure(red: Byte; green: Byte; blue: Byte)>(z_SecondaryColor3ub_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ub(red: Byte; green: Byte; blue: Byte) :=
z_SecondaryColor3ub_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3ubv_adr := GetFuncAdr('glSecondaryColor3ubv');
private z_SecondaryColor3ubv_ovr_0 := GetFuncOrNil&<procedure(var v: Byte)>(z_SecondaryColor3ubv_adr);
private z_SecondaryColor3ubv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3ubv_ovr_0(v[0]) else
z_SecondaryColor3ubv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(var v: Byte) :=
z_SecondaryColor3ubv_ovr_0(v);
private z_SecondaryColor3ubv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(v: IntPtr) :=
z_SecondaryColor3ubv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3ui_adr := GetFuncAdr('glSecondaryColor3ui');
private z_SecondaryColor3ui_ovr_0 := GetFuncOrNil&<procedure(red: UInt32; green: UInt32; blue: UInt32)>(z_SecondaryColor3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ui(red: UInt32; green: UInt32; blue: UInt32) :=
z_SecondaryColor3ui_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3uiv_adr := GetFuncAdr('glSecondaryColor3uiv');
private z_SecondaryColor3uiv_ovr_0 := GetFuncOrNil&<procedure(var v: UInt32)>(z_SecondaryColor3uiv_adr);
private z_SecondaryColor3uiv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3uiv_ovr_0(v[0]) else
z_SecondaryColor3uiv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(var v: UInt32) :=
z_SecondaryColor3uiv_ovr_0(v);
private z_SecondaryColor3uiv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(v: IntPtr) :=
z_SecondaryColor3uiv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3us_adr := GetFuncAdr('glSecondaryColor3us');
private z_SecondaryColor3us_ovr_0 := GetFuncOrNil&<procedure(red: UInt16; green: UInt16; blue: UInt16)>(z_SecondaryColor3us_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3us(red: UInt16; green: UInt16; blue: UInt16) :=
z_SecondaryColor3us_ovr_0(red, green, blue);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColor3usv_adr := GetFuncAdr('glSecondaryColor3usv');
private z_SecondaryColor3usv_ovr_0 := GetFuncOrNil&<procedure(var v: UInt16)>(z_SecondaryColor3usv_adr);
private z_SecondaryColor3usv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3usv_ovr_0(v[0]) else
z_SecondaryColor3usv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(var v: UInt16) :=
z_SecondaryColor3usv_ovr_0(v);
private z_SecondaryColor3usv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(v: IntPtr) :=
z_SecondaryColor3usv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_SecondaryColorPointer_adr := GetFuncAdr('glSecondaryColorPointer');
private z_SecondaryColorPointer_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr)>(z_SecondaryColorPointer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointer(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr) :=
z_SecondaryColorPointer_ovr_0(size, &type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_SelectBuffer_ovr_0(size: Int32; var buffer: UInt32);
external 'opengl32.dll' name 'glSelectBuffer';
private static procedure z_SelectBuffer_ovr_0_anh001(size: Int32; buffer: IntPtr);
external 'opengl32.dll' name 'glSelectBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; buffer: array of UInt32) :=
if (buffer<>nil) and (buffer.Length<>0) then
z_SelectBuffer_ovr_0(size, buffer[0]) else
z_SelectBuffer_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; var buffer: UInt32) :=
z_SelectBuffer_ovr_0(size, buffer);
private static procedure z_SelectBuffer_ovr_2(size: Int32; buffer: IntPtr);
external 'opengl32.dll' name 'glSelectBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; buffer: IntPtr) :=
z_SelectBuffer_ovr_2(size, buffer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_ShadeModel_ovr_0(mode: ShadingModel);
external 'opengl32.dll' name 'glShadeModel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadeModel(mode: ShadingModel) :=
z_ShadeModel_ovr_0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1d_ovr_0(s: real);
external 'opengl32.dll' name 'glTexCoord1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1d(s: real) :=
z_TexCoord1d_ovr_0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glTexCoord1dv';
private static procedure z_TexCoord1dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord1dv_ovr_0(v[0]) else
z_TexCoord1dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(var v: real) :=
z_TexCoord1dv_ovr_0(v);
private static procedure z_TexCoord1dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(v: IntPtr) :=
z_TexCoord1dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1f_ovr_0(s: single);
external 'opengl32.dll' name 'glTexCoord1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1f(s: single) :=
z_TexCoord1f_ovr_0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glTexCoord1fv';
private static procedure z_TexCoord1fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord1fv_ovr_0(v[0]) else
z_TexCoord1fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(var v: single) :=
z_TexCoord1fv_ovr_0(v);
private static procedure z_TexCoord1fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(v: IntPtr) :=
z_TexCoord1fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1i_ovr_0(s: Int32);
external 'opengl32.dll' name 'glTexCoord1i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1i(s: Int32) :=
z_TexCoord1i_ovr_0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glTexCoord1iv';
private static procedure z_TexCoord1iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord1iv_ovr_0(v[0]) else
z_TexCoord1iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(var v: Int32) :=
z_TexCoord1iv_ovr_0(v);
private static procedure z_TexCoord1iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(v: IntPtr) :=
z_TexCoord1iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1s_ovr_0(s: Int16);
external 'opengl32.dll' name 'glTexCoord1s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1s(s: Int16) :=
z_TexCoord1s_ovr_0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord1sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glTexCoord1sv';
private static procedure z_TexCoord1sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord1sv_ovr_0(v[0]) else
z_TexCoord1sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(var v: Int16) :=
z_TexCoord1sv_ovr_0(v);
private static procedure z_TexCoord1sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(v: IntPtr) :=
z_TexCoord1sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2d_ovr_0(s: real; t: real);
external 'opengl32.dll' name 'glTexCoord2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2d(s: real; t: real) :=
z_TexCoord2d_ovr_0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glTexCoord2dv';
private static procedure z_TexCoord2dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord2dv_ovr_0(v[0]) else
z_TexCoord2dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(var v: real) :=
z_TexCoord2dv_ovr_0(v);
private static procedure z_TexCoord2dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(v: IntPtr) :=
z_TexCoord2dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2f_ovr_0(s: single; t: single);
external 'opengl32.dll' name 'glTexCoord2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2f(s: single; t: single) :=
z_TexCoord2f_ovr_0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glTexCoord2fv';
private static procedure z_TexCoord2fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fv_ovr_0(v[0]) else
z_TexCoord2fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(var v: single) :=
z_TexCoord2fv_ovr_0(v);
private static procedure z_TexCoord2fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(v: IntPtr) :=
z_TexCoord2fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2i_ovr_0(s: Int32; t: Int32);
external 'opengl32.dll' name 'glTexCoord2i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2i(s: Int32; t: Int32) :=
z_TexCoord2i_ovr_0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glTexCoord2iv';
private static procedure z_TexCoord2iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord2iv_ovr_0(v[0]) else
z_TexCoord2iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(var v: Int32) :=
z_TexCoord2iv_ovr_0(v);
private static procedure z_TexCoord2iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(v: IntPtr) :=
z_TexCoord2iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2s_ovr_0(s: Int16; t: Int16);
external 'opengl32.dll' name 'glTexCoord2s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2s(s: Int16; t: Int16) :=
z_TexCoord2s_ovr_0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord2sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glTexCoord2sv';
private static procedure z_TexCoord2sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord2sv_ovr_0(v[0]) else
z_TexCoord2sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(var v: Int16) :=
z_TexCoord2sv_ovr_0(v);
private static procedure z_TexCoord2sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(v: IntPtr) :=
z_TexCoord2sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3d_ovr_0(s: real; t: real; r: real);
external 'opengl32.dll' name 'glTexCoord3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3d(s: real; t: real; r: real) :=
z_TexCoord3d_ovr_0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glTexCoord3dv';
private static procedure z_TexCoord3dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord3dv_ovr_0(v[0]) else
z_TexCoord3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(var v: real) :=
z_TexCoord3dv_ovr_0(v);
private static procedure z_TexCoord3dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(v: IntPtr) :=
z_TexCoord3dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3f_ovr_0(s: single; t: single; r: single);
external 'opengl32.dll' name 'glTexCoord3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3f(s: single; t: single; r: single) :=
z_TexCoord3f_ovr_0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glTexCoord3fv';
private static procedure z_TexCoord3fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord3fv_ovr_0(v[0]) else
z_TexCoord3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(var v: single) :=
z_TexCoord3fv_ovr_0(v);
private static procedure z_TexCoord3fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(v: IntPtr) :=
z_TexCoord3fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3i_ovr_0(s: Int32; t: Int32; r: Int32);
external 'opengl32.dll' name 'glTexCoord3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3i(s: Int32; t: Int32; r: Int32) :=
z_TexCoord3i_ovr_0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glTexCoord3iv';
private static procedure z_TexCoord3iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord3iv_ovr_0(v[0]) else
z_TexCoord3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(var v: Int32) :=
z_TexCoord3iv_ovr_0(v);
private static procedure z_TexCoord3iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(v: IntPtr) :=
z_TexCoord3iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3s_ovr_0(s: Int16; t: Int16; r: Int16);
external 'opengl32.dll' name 'glTexCoord3s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3s(s: Int16; t: Int16; r: Int16) :=
z_TexCoord3s_ovr_0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord3sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glTexCoord3sv';
private static procedure z_TexCoord3sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord3sv_ovr_0(v[0]) else
z_TexCoord3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(var v: Int16) :=
z_TexCoord3sv_ovr_0(v);
private static procedure z_TexCoord3sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(v: IntPtr) :=
z_TexCoord3sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4d_ovr_0(s: real; t: real; r: real; q: real);
external 'opengl32.dll' name 'glTexCoord4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4d(s: real; t: real; r: real; q: real) :=
z_TexCoord4d_ovr_0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glTexCoord4dv';
private static procedure z_TexCoord4dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord4dv_ovr_0(v[0]) else
z_TexCoord4dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(var v: real) :=
z_TexCoord4dv_ovr_0(v);
private static procedure z_TexCoord4dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(v: IntPtr) :=
z_TexCoord4dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4f_ovr_0(s: single; t: single; r: single; q: single);
external 'opengl32.dll' name 'glTexCoord4f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4f(s: single; t: single; r: single; q: single) :=
z_TexCoord4f_ovr_0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glTexCoord4fv';
private static procedure z_TexCoord4fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fv_ovr_0(v[0]) else
z_TexCoord4fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(var v: single) :=
z_TexCoord4fv_ovr_0(v);
private static procedure z_TexCoord4fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(v: IntPtr) :=
z_TexCoord4fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4i_ovr_0(s: Int32; t: Int32; r: Int32; q: Int32);
external 'opengl32.dll' name 'glTexCoord4i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4i(s: Int32; t: Int32; r: Int32; q: Int32) :=
z_TexCoord4i_ovr_0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glTexCoord4iv';
private static procedure z_TexCoord4iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord4iv_ovr_0(v[0]) else
z_TexCoord4iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(var v: Int32) :=
z_TexCoord4iv_ovr_0(v);
private static procedure z_TexCoord4iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(v: IntPtr) :=
z_TexCoord4iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4s_ovr_0(s: Int16; t: Int16; r: Int16; q: Int16);
external 'opengl32.dll' name 'glTexCoord4s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4s(s: Int16; t: Int16; r: Int16; q: Int16) :=
z_TexCoord4s_ovr_0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexCoord4sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glTexCoord4sv';
private static procedure z_TexCoord4sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord4sv_ovr_0(v[0]) else
z_TexCoord4sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(var v: Int16) :=
z_TexCoord4sv_ovr_0(v);
private static procedure z_TexCoord4sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(v: IntPtr) :=
z_TexCoord4sv_ovr_2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure z_TexCoordPointer_ovr_0(size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glTexCoordPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointer(size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr) :=
z_TexCoordPointer_ovr_0(size, &type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexEnvf_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; param: single);
external 'opengl32.dll' name 'glTexEnvf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvf(target: TextureEnvTarget; pname: TextureEnvParameter; param: single) :=
z_TexEnvf_ovr_0(target, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexEnvfv_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glTexEnvfv';
private static procedure z_TexEnvfv_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnvfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexEnvfv_ovr_0(target, pname, ¶ms[0]) else
z_TexEnvfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) :=
z_TexEnvfv_ovr_0(target, pname, ¶ms);
private static procedure z_TexEnvfv_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnvfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_TexEnvfv_ovr_2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexEnvi_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32);
external 'opengl32.dll' name 'glTexEnvi';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvi(target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32) :=
z_TexEnvi_ovr_0(target, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexEnviv_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexEnviv';
private static procedure z_TexEnviv_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnviv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexEnviv_ovr_0(target, pname, ¶ms[0]) else
z_TexEnviv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) :=
z_TexEnviv_ovr_0(target, pname, ¶ms);
private static procedure z_TexEnviv_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnviv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_TexEnviv_ovr_2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGend_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; param: real);
external 'opengl32.dll' name 'glTexGend';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGend(coord: TextureCoordName; pname: TextureGenParameter; param: real) :=
z_TexGend_ovr_0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGendv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glTexGendv';
private static procedure z_TexGendv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGendv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexGendv_ovr_0(coord, pname, ¶ms[0]) else
z_TexGendv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) :=
z_TexGendv_ovr_0(coord, pname, ¶ms);
private static procedure z_TexGendv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGendv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_TexGendv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGenf_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; param: single);
external 'opengl32.dll' name 'glTexGenf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenf(coord: TextureCoordName; pname: TextureGenParameter; param: single) :=
z_TexGenf_ovr_0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGenfv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glTexGenfv';
private static procedure z_TexGenfv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGenfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexGenfv_ovr_0(coord, pname, ¶ms[0]) else
z_TexGenfv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) :=
z_TexGenfv_ovr_0(coord, pname, ¶ms);
private static procedure z_TexGenfv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGenfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_TexGenfv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGeni_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; param: Int32);
external 'opengl32.dll' name 'glTexGeni';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeni(coord: TextureCoordName; pname: TextureGenParameter; param: Int32) :=
z_TexGeni_ovr_0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure z_TexGeniv_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexGeniv';
private static procedure z_TexGeniv_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGeniv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexGeniv_ovr_0(coord, pname, ¶ms[0]) else
z_TexGeniv_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) :=
z_TexGeniv_ovr_0(coord, pname, ¶ms);
private static procedure z_TexGeniv_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGeniv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_TexGeniv_ovr_2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Translated_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glTranslated';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Translated(x: real; y: real; z: real) :=
z_Translated_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Translatef_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glTranslatef';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Translatef(x: single; y: single; z: single) :=
z_Translatef_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2d_ovr_0(x: real; y: real);
external 'opengl32.dll' name 'glVertex2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2d(x: real; y: real) :=
z_Vertex2d_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glVertex2dv';
private static procedure z_Vertex2dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex2dv_ovr_0(v[0]) else
z_Vertex2dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(var v: real) :=
z_Vertex2dv_ovr_0(v);
private static procedure z_Vertex2dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(v: IntPtr) :=
z_Vertex2dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2f_ovr_0(x: single; y: single);
external 'opengl32.dll' name 'glVertex2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2f(x: single; y: single) :=
z_Vertex2f_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glVertex2fv';
private static procedure z_Vertex2fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex2fv_ovr_0(v[0]) else
z_Vertex2fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(var v: single) :=
z_Vertex2fv_ovr_0(v);
private static procedure z_Vertex2fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(v: IntPtr) :=
z_Vertex2fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2i_ovr_0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glVertex2i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2i(x: Int32; y: Int32) :=
z_Vertex2i_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glVertex2iv';
private static procedure z_Vertex2iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex2iv_ovr_0(v[0]) else
z_Vertex2iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(var v: Int32) :=
z_Vertex2iv_ovr_0(v);
private static procedure z_Vertex2iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(v: IntPtr) :=
z_Vertex2iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2s_ovr_0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertex2s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2s(x: Int16; y: Int16) :=
z_Vertex2s_ovr_0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex2sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glVertex2sv';
private static procedure z_Vertex2sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex2sv_ovr_0(v[0]) else
z_Vertex2sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(var v: Int16) :=
z_Vertex2sv_ovr_0(v);
private static procedure z_Vertex2sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(v: IntPtr) :=
z_Vertex2sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3d_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertex3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3d(x: real; y: real; z: real) :=
z_Vertex3d_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glVertex3dv';
private static procedure z_Vertex3dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex3dv_ovr_0(v[0]) else
z_Vertex3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(var v: real) :=
z_Vertex3dv_ovr_0(v);
private static procedure z_Vertex3dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(v: IntPtr) :=
z_Vertex3dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3f_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertex3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3f(x: single; y: single; z: single) :=
z_Vertex3f_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glVertex3fv';
private static procedure z_Vertex3fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex3fv_ovr_0(v[0]) else
z_Vertex3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(var v: single) :=
z_Vertex3fv_ovr_0(v);
private static procedure z_Vertex3fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(v: IntPtr) :=
z_Vertex3fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3i_ovr_0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glVertex3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3i(x: Int32; y: Int32; z: Int32) :=
z_Vertex3i_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glVertex3iv';
private static procedure z_Vertex3iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex3iv_ovr_0(v[0]) else
z_Vertex3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(var v: Int32) :=
z_Vertex3iv_ovr_0(v);
private static procedure z_Vertex3iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(v: IntPtr) :=
z_Vertex3iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3s_ovr_0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertex3s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3s(x: Int16; y: Int16; z: Int16) :=
z_Vertex3s_ovr_0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex3sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glVertex3sv';
private static procedure z_Vertex3sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex3sv_ovr_0(v[0]) else
z_Vertex3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(var v: Int16) :=
z_Vertex3sv_ovr_0(v);
private static procedure z_Vertex3sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(v: IntPtr) :=
z_Vertex3sv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4d_ovr_0(x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertex4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4d(x: real; y: real; z: real; w: real) :=
z_Vertex4d_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4dv_ovr_0(var v: real);
external 'opengl32.dll' name 'glVertex4dv';
private static procedure z_Vertex4dv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex4dv_ovr_0(v[0]) else
z_Vertex4dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(var v: real) :=
z_Vertex4dv_ovr_0(v);
private static procedure z_Vertex4dv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(v: IntPtr) :=
z_Vertex4dv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4f_ovr_0(x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertex4f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4f(x: single; y: single; z: single; w: single) :=
z_Vertex4f_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4fv_ovr_0(var v: single);
external 'opengl32.dll' name 'glVertex4fv';
private static procedure z_Vertex4fv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex4fv_ovr_0(v[0]) else
z_Vertex4fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(var v: single) :=
z_Vertex4fv_ovr_0(v);
private static procedure z_Vertex4fv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(v: IntPtr) :=
z_Vertex4fv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4i_ovr_0(x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glVertex4i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4i(x: Int32; y: Int32; z: Int32; w: Int32) :=
z_Vertex4i_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4iv_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glVertex4iv';
private static procedure z_Vertex4iv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex4iv_ovr_0(v[0]) else
z_Vertex4iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(var v: Int32) :=
z_Vertex4iv_ovr_0(v);
private static procedure z_Vertex4iv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(v: IntPtr) :=
z_Vertex4iv_ovr_2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4s_ovr_0(x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertex4s';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4s(x: Int16; y: Int16; z: Int16; w: Int16) :=
z_Vertex4s_ovr_0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure z_Vertex4sv_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glVertex4sv';
private static procedure z_Vertex4sv_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex4sv_ovr_0(v[0]) else
z_Vertex4sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(var v: Int16) :=
z_Vertex4sv_ovr_0(v);
private static procedure z_Vertex4sv_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4sv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(v: IntPtr) :=
z_Vertex4sv_ovr_2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure z_VertexPointer_ovr_0(size: Int32; &type: VertexPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointer(size: Int32; &type: VertexPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexPointer_ovr_0(size, &type, stride, pointer);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2d_adr := GetFuncAdr('glWindowPos2d');
private z_WindowPos2d_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real)>(z_WindowPos2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2d(x: real; y: real) :=
z_WindowPos2d_ovr_0(x, y);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2dv_adr := GetFuncAdr('glWindowPos2dv');
private z_WindowPos2dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos2dv_adr);
private z_WindowPos2dv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2dv_ovr_0(v[0]) else
z_WindowPos2dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(var v: real) :=
z_WindowPos2dv_ovr_0(v);
private z_WindowPos2dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(v: IntPtr) :=
z_WindowPos2dv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2f_adr := GetFuncAdr('glWindowPos2f');
private z_WindowPos2f_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single)>(z_WindowPos2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2f(x: single; y: single) :=
z_WindowPos2f_ovr_0(x, y);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2fv_adr := GetFuncAdr('glWindowPos2fv');
private z_WindowPos2fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos2fv_adr);
private z_WindowPos2fv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2fv_ovr_0(v[0]) else
z_WindowPos2fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(var v: single) :=
z_WindowPos2fv_ovr_0(v);
private z_WindowPos2fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(v: IntPtr) :=
z_WindowPos2fv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2i_adr := GetFuncAdr('glWindowPos2i');
private z_WindowPos2i_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32)>(z_WindowPos2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2i(x: Int32; y: Int32) :=
z_WindowPos2i_ovr_0(x, y);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2iv_adr := GetFuncAdr('glWindowPos2iv');
private z_WindowPos2iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos2iv_adr);
private z_WindowPos2iv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2iv_ovr_0(v[0]) else
z_WindowPos2iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(var v: Int32) :=
z_WindowPos2iv_ovr_0(v);
private z_WindowPos2iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(v: IntPtr) :=
z_WindowPos2iv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2s_adr := GetFuncAdr('glWindowPos2s');
private z_WindowPos2s_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16)>(z_WindowPos2s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2s(x: Int16; y: Int16) :=
z_WindowPos2s_ovr_0(x, y);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos2sv_adr := GetFuncAdr('glWindowPos2sv');
private z_WindowPos2sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos2sv_adr);
private z_WindowPos2sv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2sv_ovr_0(v[0]) else
z_WindowPos2sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(var v: Int16) :=
z_WindowPos2sv_ovr_0(v);
private z_WindowPos2sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(v: IntPtr) :=
z_WindowPos2sv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3d_adr := GetFuncAdr('glWindowPos3d');
private z_WindowPos3d_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real; z: real)>(z_WindowPos3d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3d(x: real; y: real; z: real) :=
z_WindowPos3d_ovr_0(x, y, z);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3dv_adr := GetFuncAdr('glWindowPos3dv');
private z_WindowPos3dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos3dv_adr);
private z_WindowPos3dv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3dv_ovr_0(v[0]) else
z_WindowPos3dv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(var v: real) :=
z_WindowPos3dv_ovr_0(v);
private z_WindowPos3dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(v: IntPtr) :=
z_WindowPos3dv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3f_adr := GetFuncAdr('glWindowPos3f');
private z_WindowPos3f_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single; z: single)>(z_WindowPos3f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3f(x: single; y: single; z: single) :=
z_WindowPos3f_ovr_0(x, y, z);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3fv_adr := GetFuncAdr('glWindowPos3fv');
private z_WindowPos3fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos3fv_adr);
private z_WindowPos3fv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3fv_ovr_0(v[0]) else
z_WindowPos3fv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(var v: single) :=
z_WindowPos3fv_ovr_0(v);
private z_WindowPos3fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(v: IntPtr) :=
z_WindowPos3fv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3i_adr := GetFuncAdr('glWindowPos3i');
private z_WindowPos3i_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; z: Int32)>(z_WindowPos3i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3i(x: Int32; y: Int32; z: Int32) :=
z_WindowPos3i_ovr_0(x, y, z);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3iv_adr := GetFuncAdr('glWindowPos3iv');
private z_WindowPos3iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos3iv_adr);
private z_WindowPos3iv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3iv_ovr_0(v[0]) else
z_WindowPos3iv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(var v: Int32) :=
z_WindowPos3iv_ovr_0(v);
private z_WindowPos3iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(v: IntPtr) :=
z_WindowPos3iv_ovr_2(v);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3s_adr := GetFuncAdr('glWindowPos3s');
private z_WindowPos3s_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16; z: Int16)>(z_WindowPos3s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3s(x: Int16; y: Int16; z: Int16) :=
z_WindowPos3s_ovr_0(x, y, z);
// added in gl1.4, deprecated in gl3.2
private z_WindowPos3sv_adr := GetFuncAdr('glWindowPos3sv');
private z_WindowPos3sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos3sv_adr);
private z_WindowPos3sv_ovr_0_anh01 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3sv_ovr_0(v[0]) else
z_WindowPos3sv_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(var v: Int16) :=
z_WindowPos3sv_ovr_0(v);
private z_WindowPos3sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(v: IntPtr) :=
z_WindowPos3sv_ovr_2(v);
end;
[PCUNotRestore]
wgl = static class
// added in wgl1.0
private static function z_CopyContext_ovr_0(hglrcSrc: GLContext; hglrcDst: GLContext; mask: UInt32): UInt32;
external 'opengl32.dll' name 'wglCopyContext';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CopyContext(hglrcSrc: GLContext; hglrcDst: GLContext; mask: UInt32): UInt32 :=
z_CopyContext_ovr_0(hglrcSrc, hglrcDst, mask);
// added in wgl1.0
private static function z_CreateContext_ovr_0(hDc: GDI_DC): GLContext;
external 'opengl32.dll' name 'wglCreateContext';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(hDc: GDI_DC): GLContext :=
z_CreateContext_ovr_0(hDc);
// added in wgl1.0
private static function z_CreateLayerContext_ovr_0(hDc: GDI_DC; level: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateLayerContext';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateLayerContext(hDc: GDI_DC; level: Int32): GLContext :=
z_CreateLayerContext_ovr_0(hDc, level);
// added in wgl1.0
private static function z_DeleteContext_ovr_0(oldContext: GLContext): UInt32;
external 'opengl32.dll' name 'wglDeleteContext';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteContext(oldContext: GLContext): UInt32 :=
z_DeleteContext_ovr_0(oldContext);
// added in wgl1.0
private static function z_DescribeLayerPlane_ovr_0(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; var plpd: GDI_LayerPlaneDescriptor): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
private static function z_DescribeLayerPlane_ovr_0_anh000001(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: array of GDI_LayerPlaneDescriptor): UInt32 :=
if (plpd<>nil) and (plpd.Length<>0) then
z_DescribeLayerPlane_ovr_0(hDc, pixelFormat, layerPlane, nBytes, plpd[0]) else
z_DescribeLayerPlane_ovr_0_anh000001(hDc, pixelFormat, layerPlane, nBytes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; var plpd: GDI_LayerPlaneDescriptor): UInt32 :=
z_DescribeLayerPlane_ovr_0(hDc, pixelFormat, layerPlane, nBytes, plpd);
private static function z_DescribeLayerPlane_ovr_2(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: IntPtr): UInt32 :=
z_DescribeLayerPlane_ovr_2(hDc, pixelFormat, layerPlane, nBytes, plpd);
// added in wgl1.0
private static function z_GetCurrentContext_ovr_0: GLContext;
external 'opengl32.dll' name 'wglGetCurrentContext';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentContext: GLContext :=
z_GetCurrentContext_ovr_0;
// added in wgl1.0
private static function z_GetCurrentDC_ovr_0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentDC';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentDC: GDI_DC :=
z_GetCurrentDC_ovr_0;
// added in wgl1.0
private static function z_GetLayerPaletteEntries_ovr_0(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
private static function z_GetLayerPaletteEntries_ovr_0_anh000001(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: array of GDI_COLORREF): Int32 :=
if (pcr<>nil) and (pcr.Length<>0) then
z_GetLayerPaletteEntries_ovr_0(hdc, iLayerPlane, iStart, cEntries, pcr[0]) else
z_GetLayerPaletteEntries_ovr_0_anh000001(hdc, iLayerPlane, iStart, cEntries, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32 :=
z_GetLayerPaletteEntries_ovr_0(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function z_GetLayerPaletteEntries_ovr_2(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32 :=
z_GetLayerPaletteEntries_ovr_2(hdc, iLayerPlane, iStart, cEntries, pcr);
// added in wgl1.0
private static function z_GetProcAddress_ovr_0(lpszProc: IntPtr): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProcAddress(lpszProc: IntPtr): IntPtr :=
z_GetProcAddress_ovr_0(lpszProc);
// added in wgl1.0
private static function z_MakeCurrent_ovr_0(hDc: GDI_DC; newContext: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeCurrent';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeCurrent(hDc: GDI_DC; newContext: GLContext): UInt32 :=
z_MakeCurrent_ovr_0(hDc, newContext);
// added in wgl1.0
private static function z_RealizeLayerPalette_ovr_0(hdc: GDI_DC; iLayerPlane: Int32; bRealize: UInt32): UInt32;
external 'opengl32.dll' name 'wglRealizeLayerPalette';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RealizeLayerPalette(hdc: GDI_DC; iLayerPlane: Int32; bRealize: UInt32): UInt32 :=
z_RealizeLayerPalette_ovr_0(hdc, iLayerPlane, bRealize);
// added in wgl1.0
private static function z_SetLayerPaletteEntries_ovr_0(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
private static function z_SetLayerPaletteEntries_ovr_0_anh000001(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: array of GDI_COLORREF): Int32 :=
if (pcr<>nil) and (pcr.Length<>0) then
z_SetLayerPaletteEntries_ovr_0(hdc, iLayerPlane, iStart, cEntries, pcr[0]) else
z_SetLayerPaletteEntries_ovr_0_anh000001(hdc, iLayerPlane, iStart, cEntries, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32 :=
z_SetLayerPaletteEntries_ovr_0(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function z_SetLayerPaletteEntries_ovr_2(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32 :=
z_SetLayerPaletteEntries_ovr_2(hdc, iLayerPlane, iStart, cEntries, pcr);
// added in wgl1.0
private static function z_ShareLists_ovr_0(hrcSrvShare: GLContext; hrcSrvSource: GLContext): UInt32;
external 'opengl32.dll' name 'wglShareLists';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ShareLists(hrcSrvShare: GLContext; hrcSrvSource: GLContext): UInt32 :=
z_ShareLists_ovr_0(hrcSrvShare, hrcSrvSource);
// added in wgl1.0
private static function z_SwapLayerBuffers_ovr_0(hdc: GDI_DC; fuFlags: UInt32): UInt32;
external 'opengl32.dll' name 'wglSwapLayerBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapLayerBuffers(hdc: GDI_DC; fuFlags: UInt32): UInt32 :=
z_SwapLayerBuffers_ovr_0(hdc, fuFlags);
// added in wgl1.0
private static function z_UseFontBitmaps_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmaps';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmaps(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 :=
z_UseFontBitmaps_ovr_0(hDC, first, count, listBase);
// added in wgl1.0
private static function z_UseFontBitmapsA_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmapsA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmapsA(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 :=
z_UseFontBitmapsA_ovr_0(hDC, first, count, listBase);
// added in wgl1.0
private static function z_UseFontBitmapsW_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmapsW';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmapsW(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 :=
z_UseFontBitmapsW_ovr_0(hDC, first, count, listBase);
// added in wgl1.0
private static function z_UseFontOutlines_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlines';
private static function z_UseFontOutlines_ovr_0_anh000000001(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlines(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: array of GDI_GlyphmetricsFloat): UInt32 :=
if (lpgmf<>nil) and (lpgmf.Length<>0) then
z_UseFontOutlines_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf[0]) else
z_UseFontOutlines_ovr_0_anh000000001(hDC, first, count, listBase, deviation, extrusion, format, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlines(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32 :=
z_UseFontOutlines_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function z_UseFontOutlines_ovr_2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlines(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32 :=
z_UseFontOutlines_ovr_2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
// added in wgl1.0
private static function z_UseFontOutlinesA_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesA';
private static function z_UseFontOutlinesA_ovr_0_anh000000001(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesA(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: array of GDI_GlyphmetricsFloat): UInt32 :=
if (lpgmf<>nil) and (lpgmf.Length<>0) then
z_UseFontOutlinesA_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf[0]) else
z_UseFontOutlinesA_ovr_0_anh000000001(hDC, first, count, listBase, deviation, extrusion, format, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesA(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32 :=
z_UseFontOutlinesA_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function z_UseFontOutlinesA_ovr_2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesA(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32 :=
z_UseFontOutlinesA_ovr_2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
// added in wgl1.0
private static function z_UseFontOutlinesW_ovr_0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesW';
private static function z_UseFontOutlinesW_ovr_0_anh000000001(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesW';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesW(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: array of GDI_GlyphmetricsFloat): UInt32 :=
if (lpgmf<>nil) and (lpgmf.Length<>0) then
z_UseFontOutlinesW_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf[0]) else
z_UseFontOutlinesW_ovr_0_anh000000001(hDC, first, count, listBase, deviation, extrusion, format, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesW(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; var lpgmf: GDI_GlyphmetricsFloat): UInt32 :=
z_UseFontOutlinesW_ovr_0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function z_UseFontOutlinesW_ovr_2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesW';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontOutlinesW(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32 :=
z_UseFontOutlinesW_ovr_2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
end;
[PCUNotRestore]
gdi = static class
private static function z_ChoosePixelFormat_ovr_0(hDc: GDI_DC; var pPfd: GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
private static function z_ChoosePixelFormat_ovr_0_anh001(hDc: GDI_DC; pPfd: IntPtr): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; pPfd: array of GDI_PixelFormatDescriptor): Int32 :=
if (pPfd<>nil) and (pPfd.Length<>0) then
z_ChoosePixelFormat_ovr_0(hDc, pPfd[0]) else
z_ChoosePixelFormat_ovr_0_anh001(hDc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; var pPfd: GDI_PixelFormatDescriptor): Int32 :=
z_ChoosePixelFormat_ovr_0(hDc, pPfd);
private static function z_ChoosePixelFormat_ovr_2(hDc: GDI_DC; pPfd: IntPtr): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; pPfd: IntPtr): Int32 :=
z_ChoosePixelFormat_ovr_2(hDc, pPfd);
private static function z_DescribePixelFormat_ovr_0(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; var ppfd: GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
private static function z_DescribePixelFormat_ovr_0_anh00001(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: IntPtr): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: array of GDI_PixelFormatDescriptor): Int32 :=
if (ppfd<>nil) and (ppfd.Length<>0) then
z_DescribePixelFormat_ovr_0(hdc, ipfd, cjpfd, ppfd[0]) else
z_DescribePixelFormat_ovr_0_anh00001(hdc, ipfd, cjpfd, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; var ppfd: GDI_PixelFormatDescriptor): Int32 :=
z_DescribePixelFormat_ovr_0(hdc, ipfd, cjpfd, ppfd);
private static function z_DescribePixelFormat_ovr_2(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: IntPtr): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: IntPtr): Int32 :=
z_DescribePixelFormat_ovr_2(hdc, ipfd, cjpfd, ppfd);
private static function z_GetEnhMetaFilePixelFormat_ovr_0(hemf: GDI_HENHMetafile; var ppfd: GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
private static function z_GetEnhMetaFilePixelFormat_ovr_0_anh001(hemf: GDI_HENHMetafile; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; ppfd: array of GDI_PixelFormatDescriptor): UInt32 :=
if (ppfd<>nil) and (ppfd.Length<>0) then
z_GetEnhMetaFilePixelFormat_ovr_0(hemf, ppfd[0]) else
z_GetEnhMetaFilePixelFormat_ovr_0_anh001(hemf, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; var ppfd: GDI_PixelFormatDescriptor): UInt32 :=
z_GetEnhMetaFilePixelFormat_ovr_0(hemf, ppfd);
private static function z_GetEnhMetaFilePixelFormat_ovr_2(hemf: GDI_HENHMetafile; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; ppfd: IntPtr): UInt32 :=
z_GetEnhMetaFilePixelFormat_ovr_2(hemf, ppfd);
private static function z_GetPixelFormat_ovr_0(hdc: GDI_DC): Int32;
external 'gdi32.dll' name 'GetPixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormat(hdc: GDI_DC): Int32 :=
z_GetPixelFormat_ovr_0(hdc);
private static function z_SetPixelFormat_ovr_0(hdc: GDI_DC; ipfd: Int32; var ppfd: GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
private static function z_SetPixelFormat_ovr_0_anh0001(hdc: GDI_DC; ipfd: Int32; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; ppfd: array of GDI_PixelFormatDescriptor): UInt32 :=
if (ppfd<>nil) and (ppfd.Length<>0) then
z_SetPixelFormat_ovr_0(hdc, ipfd, ppfd[0]) else
z_SetPixelFormat_ovr_0_anh0001(hdc, ipfd, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; var ppfd: GDI_PixelFormatDescriptor): UInt32 :=
z_SetPixelFormat_ovr_0(hdc, ipfd, ppfd);
private static function z_SetPixelFormat_ovr_2(hdc: GDI_DC; ipfd: Int32; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; ppfd: IntPtr): UInt32 :=
z_SetPixelFormat_ovr_2(hdc, ipfd, ppfd);
private static function z_SwapBuffers_ovr_0(hdc: GDI_DC): UInt32;
external 'gdi32.dll' name 'SwapBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapBuffers(hdc: GDI_DC): UInt32 :=
z_SwapBuffers_ovr_0(hdc);
end;
{$region Extensions}
[PCUNotRestore]
glTbuffer3DFX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TbufferMask3DFX_ovr_0(mask: UInt32);
external 'opengl32.dll' name 'glTbufferMask3DFX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TbufferMask3DFX(mask: UInt32) :=
z_TbufferMask3DFX_ovr_0(mask);
end;
[PCUNotRestore]
glDebugOutputAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DebugMessageEnableAMD_ovr_0(category: DummyEnum; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageEnableAMD';
private static procedure z_DebugMessageEnableAMD_ovr_0_anh000010(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageEnableAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean) :=
if (ids<>nil) and (ids.Length<>0) then
z_DebugMessageEnableAMD_ovr_0(category, severity, count, ids[0], enabled) else
z_DebugMessageEnableAMD_ovr_0_anh000010(category, severity, count, IntPtr.Zero, enabled);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean) :=
z_DebugMessageEnableAMD_ovr_0(category, severity, count, ids, enabled);
private static procedure z_DebugMessageEnableAMD_ovr_2(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageEnableAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean) :=
z_DebugMessageEnableAMD_ovr_2(category, severity, count, ids, enabled);
private static procedure z_DebugMessageInsertAMD_ovr_0(category: DummyEnum; severity: DebugSeverity; id: UInt32; length: Int32; buf: IntPtr);
external 'opengl32.dll' name 'glDebugMessageInsertAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsertAMD(category: DummyEnum; severity: DebugSeverity; id: UInt32; length: Int32; buf: string);
begin
var par_5_str_ptr := Marshal.StringToHGlobalAnsi(buf);
z_DebugMessageInsertAMD_ovr_0(category, severity, id, length, par_5_str_ptr);
Marshal.FreeHGlobal(par_5_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsertAMD(category: DummyEnum; severity: DebugSeverity; id: UInt32; length: Int32; buf: IntPtr) :=
z_DebugMessageInsertAMD_ovr_0(category, severity, id, length, buf);
private static procedure z_DebugMessageCallbackAMD_ovr_0(callback: GLDEBUGPROC; userParam: IntPtr);
external 'opengl32.dll' name 'glDebugMessageCallbackAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallbackAMD(callback: GLDEBUGPROC; userParam: IntPtr) :=
z_DebugMessageCallbackAMD_ovr_0(callback, userParam);
private static function z_GetDebugMessageLogAMD_ovr_0(count: UInt32; bufSize: Int32; var categories: DummyEnum; var severities: UInt32; var ids: UInt32; var lengths: Int32; message: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLogAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogAMD(count: UInt32; bufSize: Int32; var categories: DummyEnum; var severities: UInt32; var ids: UInt32; var lengths: Int32; message: IntPtr): UInt32 :=
z_GetDebugMessageLogAMD_ovr_0(count, bufSize, categories, severities, ids, lengths, message);
private static function z_GetDebugMessageLogAMD_ovr_1(count: UInt32; bufSize: Int32; categories: IntPtr; severities: IntPtr; ids: IntPtr; lengths: IntPtr; message: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLogAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogAMD(count: UInt32; bufSize: Int32; categories: IntPtr; severities: IntPtr; ids: IntPtr; lengths: IntPtr; message: IntPtr): UInt32 :=
z_GetDebugMessageLogAMD_ovr_1(count, bufSize, categories, severities, ids, lengths, message);
end;
[PCUNotRestore]
glDrawBuffersBlendAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendFuncIndexedAMD_ovr_0(buf: UInt32; src: DummyEnum; dst: DummyEnum);
external 'opengl32.dll' name 'glBlendFuncIndexedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncIndexedAMD(buf: UInt32; src: DummyEnum; dst: DummyEnum) :=
z_BlendFuncIndexedAMD_ovr_0(buf, src, dst);
private static procedure z_BlendFuncSeparateIndexedAMD_ovr_0(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor);
external 'opengl32.dll' name 'glBlendFuncSeparateIndexedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateIndexedAMD(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor) :=
z_BlendFuncSeparateIndexedAMD_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
private static procedure z_BlendEquationIndexedAMD_ovr_0(buf: UInt32; mode: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationIndexedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationIndexedAMD(buf: UInt32; mode: BlendEquationModeEXT) :=
z_BlendEquationIndexedAMD_ovr_0(buf, mode);
private static procedure z_BlendEquationSeparateIndexedAMD_ovr_0(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationSeparateIndexedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateIndexedAMD(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT) :=
z_BlendEquationSeparateIndexedAMD_ovr_0(buf, modeRGB, modeAlpha);
end;
[PCUNotRestore]
glFramebufferMultisampleAdvancedAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RenderbufferStorageMultisampleAdvancedAMD_ovr_0(target: RenderbufferTarget; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorageMultisampleAdvancedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleAdvancedAMD(target: RenderbufferTarget; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageMultisampleAdvancedAMD_ovr_0(target, samples, storageSamples, _internalformat, width, height);
private static procedure z_NamedRenderbufferStorageMultisampleAdvancedAMD_ovr_0(renderbuffer: UInt32; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorageMultisampleAdvancedAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer: UInt32; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageMultisampleAdvancedAMD_ovr_0(renderbuffer, samples, storageSamples, _internalformat, width, height);
end;
[PCUNotRestore]
glFramebufferSamplePositionsAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferSamplePositionsfvAMD_ovr_0(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; var values: single);
external 'opengl32.dll' name 'glFramebufferSamplePositionsfvAMD';
private static procedure z_FramebufferSamplePositionsfvAMD_ovr_0_anh00001(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
external 'opengl32.dll' name 'glFramebufferSamplePositionsfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_FramebufferSamplePositionsfvAMD_ovr_0(target, numsamples, pixelindex, values[0]) else
z_FramebufferSamplePositionsfvAMD_ovr_0_anh00001(target, numsamples, pixelindex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; var values: single) :=
z_FramebufferSamplePositionsfvAMD_ovr_0(target, numsamples, pixelindex, values);
private static procedure z_FramebufferSamplePositionsfvAMD_ovr_2(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
external 'opengl32.dll' name 'glFramebufferSamplePositionsfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: IntPtr) :=
z_FramebufferSamplePositionsfvAMD_ovr_2(target, numsamples, pixelindex, values);
private static procedure z_NamedFramebufferSamplePositionsfvAMD_ovr_0(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; var values: single);
external 'opengl32.dll' name 'glNamedFramebufferSamplePositionsfvAMD';
private static procedure z_NamedFramebufferSamplePositionsfvAMD_ovr_0_anh00001(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSamplePositionsfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_NamedFramebufferSamplePositionsfvAMD_ovr_0(framebuffer, numsamples, pixelindex, values[0]) else
z_NamedFramebufferSamplePositionsfvAMD_ovr_0_anh00001(framebuffer, numsamples, pixelindex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; var values: single) :=
z_NamedFramebufferSamplePositionsfvAMD_ovr_0(framebuffer, numsamples, pixelindex, values);
private static procedure z_NamedFramebufferSamplePositionsfvAMD_ovr_2(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSamplePositionsfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: IntPtr) :=
z_NamedFramebufferSamplePositionsfvAMD_ovr_2(framebuffer, numsamples, pixelindex, values);
private static procedure z_GetFramebufferParameterfvAMD_ovr_0(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single);
external 'opengl32.dll' name 'glGetFramebufferParameterfvAMD';
private static procedure z_GetFramebufferParameterfvAMD_ovr_0_anh0000001(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_GetFramebufferParameterfvAMD_ovr_0(target, pname, numsamples, pixelindex, size, values[0]) else
z_GetFramebufferParameterfvAMD_ovr_0_anh0000001(target, pname, numsamples, pixelindex, size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single) :=
z_GetFramebufferParameterfvAMD_ovr_0(target, pname, numsamples, pixelindex, size, values);
private static procedure z_GetFramebufferParameterfvAMD_ovr_2(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr) :=
z_GetFramebufferParameterfvAMD_ovr_2(target, pname, numsamples, pixelindex, size, values);
private static procedure z_GetNamedFramebufferParameterfvAMD_ovr_0(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterfvAMD';
private static procedure z_GetNamedFramebufferParameterfvAMD_ovr_0_anh0000001(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_GetNamedFramebufferParameterfvAMD_ovr_0(framebuffer, pname, numsamples, pixelindex, size, values[0]) else
z_GetNamedFramebufferParameterfvAMD_ovr_0_anh0000001(framebuffer, pname, numsamples, pixelindex, size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single) :=
z_GetNamedFramebufferParameterfvAMD_ovr_0(framebuffer, pname, numsamples, pixelindex, size, values);
private static procedure z_GetNamedFramebufferParameterfvAMD_ovr_2(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterfvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr) :=
z_GetNamedFramebufferParameterfvAMD_ovr_2(framebuffer, pname, numsamples, pixelindex, size, values);
end;
[PCUNotRestore]
glGpuShaderInt64AMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Uniform1i64NV_ovr_0(location: Int32; x: Int64);
external 'opengl32.dll' name 'glUniform1i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64NV(location: Int32; x: Int64) :=
z_Uniform1i64NV_ovr_0(location, x);
private static procedure z_Uniform2i64NV_ovr_0(location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glUniform2i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64NV(location: Int32; x: Int64; y: Int64) :=
z_Uniform2i64NV_ovr_0(location, x, y);
private static procedure z_Uniform3i64NV_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glUniform3i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64NV(location: Int32; x: Int64; y: Int64; z: Int64) :=
z_Uniform3i64NV_ovr_0(location, x, y, z);
private static procedure z_Uniform4i64NV_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glUniform4i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64NV(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_Uniform4i64NV_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform1i64vNV';
private static procedure z_Uniform1i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1i64vNV_ovr_0(location, count, value[0]) else
z_Uniform1i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform1i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform1i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform2i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform2i64vNV';
private static procedure z_Uniform2i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2i64vNV_ovr_0(location, count, value[0]) else
z_Uniform2i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform2i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform2i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform3i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform3i64vNV';
private static procedure z_Uniform3i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3i64vNV_ovr_0(location, count, value[0]) else
z_Uniform3i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform3i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform3i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform4i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform4i64vNV';
private static procedure z_Uniform4i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4i64vNV_ovr_0(location, count, value[0]) else
z_Uniform4i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform4i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform4i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform1ui64NV_ovr_0(location: Int32; x: UInt64);
external 'opengl32.dll' name 'glUniform1ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64NV(location: Int32; x: UInt64) :=
z_Uniform1ui64NV_ovr_0(location, x);
private static procedure z_Uniform2ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glUniform2ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64NV(location: Int32; x: UInt64; y: UInt64) :=
z_Uniform2ui64NV_ovr_0(location, x, y);
private static procedure z_Uniform3ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glUniform3ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_Uniform3ui64NV_ovr_0(location, x, y, z);
private static procedure z_Uniform4ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glUniform4ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_Uniform4ui64NV_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform1ui64vNV';
private static procedure z_Uniform1ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform1ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform1ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform1ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform2ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform2ui64vNV';
private static procedure z_Uniform2ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform2ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform2ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform2ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform3ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform3ui64vNV';
private static procedure z_Uniform3ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform3ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform3ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform3ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform4ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform4ui64vNV';
private static procedure z_Uniform4ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform4ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform4ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform4ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4ui64vNV_ovr_2(location, count, value);
private static procedure z_GetUniformi64vNV_ovr_0(&program: UInt32; location: Int32; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetUniformi64vNV';
private static procedure z_GetUniformi64vNV_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformi64vNV_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; var ¶ms: Int64) :=
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformi64vNV_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformi64vNV_ovr_2(&program, location, ¶ms);
private static procedure z_GetUniformui64vNV_ovr_0(&program: UInt32; location: Int32; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetUniformui64vNV';
private static procedure z_GetUniformui64vNV_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformui64vNV_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; var ¶ms: UInt64) :=
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformui64vNV_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformui64vNV_ovr_2(&program, location, ¶ms);
private static procedure z_ProgramUniform1i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64NV(&program: UInt32; location: Int32; x: Int64) :=
z_ProgramUniform1i64NV_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64) :=
z_ProgramUniform2i64NV_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64) :=
z_ProgramUniform3i64NV_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_ProgramUniform4i64NV_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
private static procedure z_ProgramUniform1i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
private static procedure z_ProgramUniform2i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
private static procedure z_ProgramUniform3i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
private static procedure z_ProgramUniform4i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64NV(&program: UInt32; location: Int32; x: UInt64) :=
z_ProgramUniform1ui64NV_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64) :=
z_ProgramUniform2ui64NV_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_ProgramUniform3ui64NV_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_ProgramUniform4ui64NV_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
private static procedure z_ProgramUniform1ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
private static procedure z_ProgramUniform2ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
private static procedure z_ProgramUniform3ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
private static procedure z_ProgramUniform4ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4ui64vNV_ovr_2(&program, location, count, value);
end;
[PCUNotRestore]
glInterleavedElementsAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribParameteriAMD_ovr_0(index: UInt32; pname: DummyEnum; param: Int32);
external 'opengl32.dll' name 'glVertexAttribParameteriAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribParameteriAMD(index: UInt32; pname: DummyEnum; param: Int32) :=
z_VertexAttribParameteriAMD_ovr_0(index, pname, param);
end;
[PCUNotRestore]
glMultiDrawIndirectAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysIndirectAMD_ovr_0(mode: PrimitiveType; indirect: IntPtr; primcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysIndirectAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectAMD(mode: PrimitiveType; indirect: IntPtr; primcount: Int32; stride: Int32) :=
z_MultiDrawArraysIndirectAMD_ovr_0(mode, indirect, primcount, stride);
private static procedure z_MultiDrawElementsIndirectAMD_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; primcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsIndirectAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectAMD(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; primcount: Int32; stride: Int32) :=
z_MultiDrawElementsIndirectAMD_ovr_0(mode, &type, indirect, primcount, stride);
end;
[PCUNotRestore]
glNameGenDeleteAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenNamesAMD_ovr_0(identifier: DummyEnum; num: UInt32; var names: UInt32);
external 'opengl32.dll' name 'glGenNamesAMD';
private static procedure z_GenNamesAMD_ovr_0_anh0001(identifier: DummyEnum; num: UInt32; names: IntPtr);
external 'opengl32.dll' name 'glGenNamesAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; names: array of UInt32) :=
if (names<>nil) and (names.Length<>0) then
z_GenNamesAMD_ovr_0(identifier, num, names[0]) else
z_GenNamesAMD_ovr_0_anh0001(identifier, num, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; var names: UInt32) :=
z_GenNamesAMD_ovr_0(identifier, num, names);
private static procedure z_GenNamesAMD_ovr_2(identifier: DummyEnum; num: UInt32; names: IntPtr);
external 'opengl32.dll' name 'glGenNamesAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; names: IntPtr) :=
z_GenNamesAMD_ovr_2(identifier, num, names);
private static procedure z_DeleteNamesAMD_ovr_0(identifier: DummyEnum; num: UInt32; var names: UInt32);
external 'opengl32.dll' name 'glDeleteNamesAMD';
private static procedure z_DeleteNamesAMD_ovr_0_anh0001(identifier: DummyEnum; num: UInt32; names: IntPtr);
external 'opengl32.dll' name 'glDeleteNamesAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; names: array of UInt32) :=
if (names<>nil) and (names.Length<>0) then
z_DeleteNamesAMD_ovr_0(identifier, num, names[0]) else
z_DeleteNamesAMD_ovr_0_anh0001(identifier, num, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; var names: UInt32) :=
z_DeleteNamesAMD_ovr_0(identifier, num, names);
private static procedure z_DeleteNamesAMD_ovr_2(identifier: DummyEnum; num: UInt32; names: IntPtr);
external 'opengl32.dll' name 'glDeleteNamesAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; names: IntPtr) :=
z_DeleteNamesAMD_ovr_2(identifier, num, names);
private static function z_IsNameAMD_ovr_0(identifier: DummyEnum; name: UInt32): boolean;
external 'opengl32.dll' name 'glIsNameAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNameAMD(identifier: DummyEnum; name: UInt32): boolean :=
z_IsNameAMD_ovr_0(identifier, name);
end;
[PCUNotRestore]
glOcclusionQueryEventAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_QueryObjectParameteruiAMD_ovr_0(target: QueryTarget; id: UInt32; pname: DummyEnum; param: UInt32);
external 'opengl32.dll' name 'glQueryObjectParameteruiAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryObjectParameteruiAMD(target: QueryTarget; id: UInt32; pname: DummyEnum; param: UInt32) :=
z_QueryObjectParameteruiAMD_ovr_0(target, id, pname, param);
end;
[PCUNotRestore]
glPerformanceMonitorAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetPerfMonitorGroupsAMD_ovr_0(var numGroups: Int32; groupsSize: Int32; var groups: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
private static procedure z_GetPerfMonitorGroupsAMD_ovr_0_anh0100(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
private static procedure z_GetPerfMonitorGroupsAMD_ovr_0_anh0001(var numGroups: Int32; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
private static procedure z_GetPerfMonitorGroupsAMD_ovr_0_anh0101(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; groups: array of UInt32) :=
if (numGroups<>nil) and (numGroups.Length<>0) then
if (groups<>nil) and (groups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups[0], groupsSize, groups[0]) else
z_GetPerfMonitorGroupsAMD_ovr_0_anh0001(numGroups[0], groupsSize, IntPtr.Zero) else
if (groups<>nil) and (groups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_0_anh0100(IntPtr.Zero, groupsSize, groups[0]) else
z_GetPerfMonitorGroupsAMD_ovr_0_anh0101(IntPtr.Zero, groupsSize, IntPtr.Zero);
private static procedure z_GetPerfMonitorGroupsAMD_ovr_1_anh0100(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; var groups: UInt32) :=
if (numGroups<>nil) and (numGroups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups[0], groupsSize, groups) else
z_GetPerfMonitorGroupsAMD_ovr_0_anh0100(IntPtr.Zero, groupsSize, groups);
private static procedure z_GetPerfMonitorGroupsAMD_ovr_2(var numGroups: Int32; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
private static procedure z_GetPerfMonitorGroupsAMD_ovr_2_anh0100(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; groups: IntPtr) :=
if (numGroups<>nil) and (numGroups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_2(numGroups[0], groupsSize, groups) else
z_GetPerfMonitorGroupsAMD_ovr_2_anh0100(IntPtr.Zero, groupsSize, groups);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; groups: array of UInt32) :=
if (groups<>nil) and (groups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups, groupsSize, groups[0]) else
z_GetPerfMonitorGroupsAMD_ovr_0_anh0001(numGroups, groupsSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; var groups: UInt32) :=
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups, groupsSize, groups);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; groups: IntPtr) :=
z_GetPerfMonitorGroupsAMD_ovr_2(numGroups, groupsSize, groups);
private static procedure z_GetPerfMonitorGroupsAMD_ovr_6(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
private static procedure z_GetPerfMonitorGroupsAMD_ovr_6_anh0001(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; groups: array of UInt32) :=
if (groups<>nil) and (groups.Length<>0) then
z_GetPerfMonitorGroupsAMD_ovr_6(numGroups, groupsSize, groups[0]) else
z_GetPerfMonitorGroupsAMD_ovr_6_anh0001(numGroups, groupsSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32) :=
z_GetPerfMonitorGroupsAMD_ovr_6(numGroups, groupsSize, groups);
private static procedure z_GetPerfMonitorGroupsAMD_ovr_8(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr) :=
z_GetPerfMonitorGroupsAMD_ovr_8(numGroups, groupsSize, groups);
private static procedure z_GetPerfMonitorCountersAMD_ovr_0(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh000100(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh001100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh000001(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh001001(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh000101(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_0_anh001101(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters[0], counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000001(group, numCounters[0], maxActiveCounters[0], counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh000100(group, numCounters[0], IntPtr.Zero, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000101(group, numCounters[0], IntPtr.Zero, counterSize, IntPtr.Zero) else
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh001000(group, IntPtr.Zero, maxActiveCounters[0], counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh001001(group, IntPtr.Zero, maxActiveCounters[0], counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh001100(group, IntPtr.Zero, IntPtr.Zero, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh001101(group, IntPtr.Zero, IntPtr.Zero, counterSize, IntPtr.Zero);
private static procedure z_GetPerfMonitorCountersAMD_ovr_1_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_1_anh000100(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_1_anh001100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000100(group, numCounters[0], IntPtr.Zero, counterSize, counters) else
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh001000(group, IntPtr.Zero, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_0_anh001100(group, IntPtr.Zero, IntPtr.Zero, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_2(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_2_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_2_anh000100(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_2_anh001100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters[0], maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_2_anh000100(group, numCounters[0], IntPtr.Zero, counterSize, counters) else
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_2_anh001000(group, IntPtr.Zero, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_2_anh001100(group, IntPtr.Zero, IntPtr.Zero, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_3_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_3_anh001001(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000001(group, numCounters[0], maxActiveCounters, counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh001001(group, IntPtr.Zero, maxActiveCounters, counterSize, IntPtr.Zero);
private static procedure z_GetPerfMonitorCountersAMD_ovr_4_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters, counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_0_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_5_anh001000(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters[0], maxActiveCounters, counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_2_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_6(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_6_anh001000(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_6_anh000001(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_6_anh001001(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters[0], maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_6_anh000001(group, numCounters[0], maxActiveCounters, counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_6_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_6_anh001001(group, IntPtr.Zero, maxActiveCounters, counterSize, IntPtr.Zero);
private static procedure z_GetPerfMonitorCountersAMD_ovr_7_anh001000(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters[0], maxActiveCounters, counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_6_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_8(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_8_anh001000(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr) :=
if (numCounters<>nil) and (numCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_8(group, numCounters[0], maxActiveCounters, counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_8_anh001000(group, IntPtr.Zero, maxActiveCounters, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters[0], counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000001(group, numCounters, maxActiveCounters[0], counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000101(group, numCounters, IntPtr.Zero, counterSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_2_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32) :=
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_0_anh000001(group, numCounters, maxActiveCounters, counterSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32) :=
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr) :=
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters, maxActiveCounters, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32) :=
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_6_anh000001(group, numCounters, maxActiveCounters, counterSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32) :=
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters, maxActiveCounters, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr) :=
z_GetPerfMonitorCountersAMD_ovr_8(group, numCounters, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_18(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_18_anh000100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_18_anh000001(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_18_anh000101(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters[0], counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_18_anh000001(group, numCounters, maxActiveCounters[0], counterSize, IntPtr.Zero) else
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_18_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_18_anh000101(group, numCounters, IntPtr.Zero, counterSize, IntPtr.Zero);
private static procedure z_GetPerfMonitorCountersAMD_ovr_19_anh000100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_18_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_20(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_20_anh000100(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr) :=
if (maxActiveCounters<>nil) and (maxActiveCounters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_20(group, numCounters, maxActiveCounters[0], counterSize, counters) else
z_GetPerfMonitorCountersAMD_ovr_20_anh000100(group, numCounters, IntPtr.Zero, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32) :=
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_18_anh000001(group, numCounters, maxActiveCounters, counterSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32) :=
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters, counterSize, counters);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr) :=
z_GetPerfMonitorCountersAMD_ovr_20(group, numCounters, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_24(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
private static procedure z_GetPerfMonitorCountersAMD_ovr_24_anh000001(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32) :=
if (counters<>nil) and (counters.Length<>0) then
z_GetPerfMonitorCountersAMD_ovr_24(group, numCounters, maxActiveCounters, counterSize, counters[0]) else
z_GetPerfMonitorCountersAMD_ovr_24_anh000001(group, numCounters, maxActiveCounters, counterSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32) :=
z_GetPerfMonitorCountersAMD_ovr_24(group, numCounters, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorCountersAMD_ovr_26(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr) :=
z_GetPerfMonitorCountersAMD_ovr_26(group, numCounters, maxActiveCounters, counterSize, counters);
private static procedure z_GetPerfMonitorGroupStringAMD_ovr_0(group: UInt32; bufSize: Int32; var length: Int32; groupString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupStringAMD';
private static procedure z_GetPerfMonitorGroupStringAMD_ovr_0_anh00010(group: UInt32; bufSize: Int32; length: IntPtr; groupString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupStringAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; length: array of Int32; groupString: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetPerfMonitorGroupStringAMD_ovr_0(group, bufSize, length[0], groupString) else
z_GetPerfMonitorGroupStringAMD_ovr_0_anh00010(group, bufSize, IntPtr.Zero, groupString);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; var length: Int32; groupString: IntPtr) :=
z_GetPerfMonitorGroupStringAMD_ovr_0(group, bufSize, length, groupString);
private static procedure z_GetPerfMonitorGroupStringAMD_ovr_2(group: UInt32; bufSize: Int32; length: IntPtr; groupString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorGroupStringAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; length: IntPtr; groupString: IntPtr) :=
z_GetPerfMonitorGroupStringAMD_ovr_2(group, bufSize, length, groupString);
private static procedure z_GetPerfMonitorCounterStringAMD_ovr_0(group: UInt32; counter: UInt32; bufSize: Int32; var length: Int32; counterString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterStringAMD';
private static procedure z_GetPerfMonitorCounterStringAMD_ovr_0_anh000010(group: UInt32; counter: UInt32; bufSize: Int32; length: IntPtr; counterString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterStringAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; length: array of Int32; counterString: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetPerfMonitorCounterStringAMD_ovr_0(group, counter, bufSize, length[0], counterString) else
z_GetPerfMonitorCounterStringAMD_ovr_0_anh000010(group, counter, bufSize, IntPtr.Zero, counterString);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; var length: Int32; counterString: IntPtr) :=
z_GetPerfMonitorCounterStringAMD_ovr_0(group, counter, bufSize, length, counterString);
private static procedure z_GetPerfMonitorCounterStringAMD_ovr_2(group: UInt32; counter: UInt32; bufSize: Int32; length: IntPtr; counterString: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterStringAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; length: IntPtr; counterString: IntPtr) :=
z_GetPerfMonitorCounterStringAMD_ovr_2(group, counter, bufSize, length, counterString);
private static procedure z_GetPerfMonitorCounterInfoAMD_ovr_0(group: UInt32; counter: UInt32; pname: DummyEnum; data: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterInfoAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterInfoAMD(group: UInt32; counter: UInt32; pname: DummyEnum; data: IntPtr) :=
z_GetPerfMonitorCounterInfoAMD_ovr_0(group, counter, pname, data);
private static procedure z_GenPerfMonitorsAMD_ovr_0(n: Int32; var monitors: UInt32);
external 'opengl32.dll' name 'glGenPerfMonitorsAMD';
private static procedure z_GenPerfMonitorsAMD_ovr_0_anh001(n: Int32; monitors: IntPtr);
external 'opengl32.dll' name 'glGenPerfMonitorsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; monitors: array of UInt32) :=
if (monitors<>nil) and (monitors.Length<>0) then
z_GenPerfMonitorsAMD_ovr_0(n, monitors[0]) else
z_GenPerfMonitorsAMD_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; var monitors: UInt32) :=
z_GenPerfMonitorsAMD_ovr_0(n, monitors);
private static procedure z_GenPerfMonitorsAMD_ovr_2(n: Int32; monitors: IntPtr);
external 'opengl32.dll' name 'glGenPerfMonitorsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; monitors: IntPtr) :=
z_GenPerfMonitorsAMD_ovr_2(n, monitors);
private static procedure z_DeletePerfMonitorsAMD_ovr_0(n: Int32; var monitors: UInt32);
external 'opengl32.dll' name 'glDeletePerfMonitorsAMD';
private static procedure z_DeletePerfMonitorsAMD_ovr_0_anh001(n: Int32; monitors: IntPtr);
external 'opengl32.dll' name 'glDeletePerfMonitorsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; monitors: array of UInt32) :=
if (monitors<>nil) and (monitors.Length<>0) then
z_DeletePerfMonitorsAMD_ovr_0(n, monitors[0]) else
z_DeletePerfMonitorsAMD_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; var monitors: UInt32) :=
z_DeletePerfMonitorsAMD_ovr_0(n, monitors);
private static procedure z_DeletePerfMonitorsAMD_ovr_2(n: Int32; monitors: IntPtr);
external 'opengl32.dll' name 'glDeletePerfMonitorsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; monitors: IntPtr) :=
z_DeletePerfMonitorsAMD_ovr_2(n, monitors);
private static procedure z_SelectPerfMonitorCountersAMD_ovr_0(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; var counterList: UInt32);
external 'opengl32.dll' name 'glSelectPerfMonitorCountersAMD';
private static procedure z_SelectPerfMonitorCountersAMD_ovr_0_anh000001(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: IntPtr);
external 'opengl32.dll' name 'glSelectPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: array of UInt32) :=
if (counterList<>nil) and (counterList.Length<>0) then
z_SelectPerfMonitorCountersAMD_ovr_0(monitor, enable, group, numCounters, counterList[0]) else
z_SelectPerfMonitorCountersAMD_ovr_0_anh000001(monitor, enable, group, numCounters, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; var counterList: UInt32) :=
z_SelectPerfMonitorCountersAMD_ovr_0(monitor, enable, group, numCounters, counterList);
private static procedure z_SelectPerfMonitorCountersAMD_ovr_2(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: IntPtr);
external 'opengl32.dll' name 'glSelectPerfMonitorCountersAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: IntPtr) :=
z_SelectPerfMonitorCountersAMD_ovr_2(monitor, enable, group, numCounters, counterList);
private static procedure z_BeginPerfMonitorAMD_ovr_0(monitor: UInt32);
external 'opengl32.dll' name 'glBeginPerfMonitorAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginPerfMonitorAMD(monitor: UInt32) :=
z_BeginPerfMonitorAMD_ovr_0(monitor);
private static procedure z_EndPerfMonitorAMD_ovr_0(monitor: UInt32);
external 'opengl32.dll' name 'glEndPerfMonitorAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndPerfMonitorAMD(monitor: UInt32) :=
z_EndPerfMonitorAMD_ovr_0(monitor);
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_0(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; var bytesWritten: Int32);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_0_anh000010(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_0_anh000001(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_0_anh000011(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; bytesWritten: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
if (bytesWritten<>nil) and (bytesWritten.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data[0], bytesWritten[0]) else
z_GetPerfMonitorCounterDataAMD_ovr_0_anh000001(monitor, pname, dataSize, data[0], IntPtr.Zero) else
if (bytesWritten<>nil) and (bytesWritten.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_0_anh000010(monitor, pname, dataSize, IntPtr.Zero, bytesWritten[0]) else
z_GetPerfMonitorCounterDataAMD_ovr_0_anh000011(monitor, pname, dataSize, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_1_anh000010(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; var bytesWritten: Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data[0], bytesWritten) else
z_GetPerfMonitorCounterDataAMD_ovr_0_anh000010(monitor, pname, dataSize, IntPtr.Zero, bytesWritten);
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_2(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_2_anh000010(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; bytesWritten: IntPtr) :=
if (data<>nil) and (data.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_2(monitor, pname, dataSize, data[0], bytesWritten) else
z_GetPerfMonitorCounterDataAMD_ovr_2_anh000010(monitor, pname, dataSize, IntPtr.Zero, bytesWritten);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: array of Int32) :=
if (bytesWritten<>nil) and (bytesWritten.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data, bytesWritten[0]) else
z_GetPerfMonitorCounterDataAMD_ovr_0_anh000001(monitor, pname, dataSize, data, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; var bytesWritten: Int32) :=
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data, bytesWritten);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: IntPtr) :=
z_GetPerfMonitorCounterDataAMD_ovr_2(monitor, pname, dataSize, data, bytesWritten);
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_6(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_6_anh000001(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: array of Int32) :=
if (bytesWritten<>nil) and (bytesWritten.Length<>0) then
z_GetPerfMonitorCounterDataAMD_ovr_6(monitor, pname, dataSize, data, bytesWritten[0]) else
z_GetPerfMonitorCounterDataAMD_ovr_6_anh000001(monitor, pname, dataSize, data, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32) :=
z_GetPerfMonitorCounterDataAMD_ovr_6(monitor, pname, dataSize, data, bytesWritten);
private static procedure z_GetPerfMonitorCounterDataAMD_ovr_8(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfMonitorCounterDataAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr) :=
z_GetPerfMonitorCounterDataAMD_ovr_8(monitor, pname, dataSize, data, bytesWritten);
end;
[PCUNotRestore]
glSamplePositionsAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SetMultisamplefvAMD_ovr_0(pname: DummyEnum; index: UInt32; var val: single);
external 'opengl32.dll' name 'glSetMultisamplefvAMD';
private static procedure z_SetMultisamplefvAMD_ovr_0_anh0001(pname: DummyEnum; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glSetMultisamplefvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; val: array of single) :=
if (val<>nil) and (val.Length<>0) then
z_SetMultisamplefvAMD_ovr_0(pname, index, val[0]) else
z_SetMultisamplefvAMD_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; var val: single) :=
z_SetMultisamplefvAMD_ovr_0(pname, index, val);
private static procedure z_SetMultisamplefvAMD_ovr_2(pname: DummyEnum; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glSetMultisamplefvAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; val: IntPtr) :=
z_SetMultisamplefvAMD_ovr_2(pname, index, val);
end;
[PCUNotRestore]
glSparseTextureAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexStorageSparseAMD_ovr_0(target: TextureTarget; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD);
external 'opengl32.dll' name 'glTexStorageSparseAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageSparseAMD(target: TextureTarget; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD) :=
z_TexStorageSparseAMD_ovr_0(target, _internalFormat, width, height, depth, layers, flags);
private static procedure z_TextureStorageSparseAMD_ovr_0(texture: UInt32; target: DummyEnum; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD);
external 'opengl32.dll' name 'glTextureStorageSparseAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageSparseAMD(texture: UInt32; target: DummyEnum; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD) :=
z_TextureStorageSparseAMD_ovr_0(texture, target, _internalFormat, width, height, depth, layers, flags);
end;
[PCUNotRestore]
glStencilOperationExtendedAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_StencilOpValueAMD_ovr_0(face: StencilFaceDirection; value: UInt32);
external 'opengl32.dll' name 'glStencilOpValueAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOpValueAMD(face: StencilFaceDirection; value: UInt32) :=
z_StencilOpValueAMD_ovr_0(face, value);
end;
[PCUNotRestore]
glVertexShaderTessellatorAMD = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TessellationFactorAMD_ovr_0(factor: single);
external 'opengl32.dll' name 'glTessellationFactorAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TessellationFactorAMD(factor: single) :=
z_TessellationFactorAMD_ovr_0(factor);
private static procedure z_TessellationModeAMD_ovr_0(mode: DummyEnum);
external 'opengl32.dll' name 'glTessellationModeAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TessellationModeAMD(mode: DummyEnum) :=
z_TessellationModeAMD_ovr_0(mode);
end;
[PCUNotRestore]
glElementArrayAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ElementPointerAPPLE_ovr_0(&type: ElementPointerTypeATI; pointer: IntPtr);
external 'opengl32.dll' name 'glElementPointerAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ElementPointerAPPLE(&type: ElementPointerTypeATI; pointer: IntPtr) :=
z_ElementPointerAPPLE_ovr_0(&type, pointer);
private static procedure z_DrawElementArrayAPPLE_ovr_0(mode: PrimitiveType; first: Int32; count: Int32);
external 'opengl32.dll' name 'glDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementArrayAPPLE(mode: PrimitiveType; first: Int32; count: Int32) :=
z_DrawElementArrayAPPLE_ovr_0(mode, first, count);
private static procedure z_DrawRangeElementArrayAPPLE_ovr_0(mode: PrimitiveType; start: UInt32; &end: UInt32; first: Int32; count: Int32);
external 'opengl32.dll' name 'glDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: Int32; count: Int32) :=
z_DrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count);
private static procedure z_MultiDrawElementArrayAPPLE_ovr_0(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
private static procedure z_MultiDrawElementArrayAPPLE_ovr_0_anh00100(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
private static procedure z_MultiDrawElementArrayAPPLE_ovr_0_anh00010(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
private static procedure z_MultiDrawElementArrayAPPLE_ovr_0_anh00110(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first[0], count[0], primcount) else
z_MultiDrawElementArrayAPPLE_ovr_0_anh00010(mode, first[0], IntPtr.Zero, primcount) else
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_0_anh00100(mode, IntPtr.Zero, count[0], primcount) else
z_MultiDrawElementArrayAPPLE_ovr_0_anh00110(mode, IntPtr.Zero, IntPtr.Zero, primcount);
private static procedure z_MultiDrawElementArrayAPPLE_ovr_1_anh00100(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first[0], count, primcount) else
z_MultiDrawElementArrayAPPLE_ovr_0_anh00100(mode, IntPtr.Zero, count, primcount);
private static procedure z_MultiDrawElementArrayAPPLE_ovr_2(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
private static procedure z_MultiDrawElementArrayAPPLE_ovr_2_anh00100(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_2(mode, first[0], count, primcount) else
z_MultiDrawElementArrayAPPLE_ovr_2_anh00100(mode, IntPtr.Zero, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first, count[0], primcount) else
z_MultiDrawElementArrayAPPLE_ovr_0_anh00010(mode, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32) :=
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32) :=
z_MultiDrawElementArrayAPPLE_ovr_2(mode, first, count, primcount);
private static procedure z_MultiDrawElementArrayAPPLE_ovr_6(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
private static procedure z_MultiDrawElementArrayAPPLE_ovr_6_anh00010(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementArrayAPPLE_ovr_6(mode, first, count[0], primcount) else
z_MultiDrawElementArrayAPPLE_ovr_6_anh00010(mode, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32) :=
z_MultiDrawElementArrayAPPLE_ovr_6(mode, first, count, primcount);
private static procedure z_MultiDrawElementArrayAPPLE_ovr_8(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32) :=
z_MultiDrawElementArrayAPPLE_ovr_8(mode, first, count, primcount);
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000100(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000010(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000110(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; count: array of Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first[0], count[0], primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000010(mode, start, &end, first[0], IntPtr.Zero, primcount) else
if (count<>nil) and (count.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000100(mode, start, &end, IntPtr.Zero, count[0], primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000110(mode, start, &end, IntPtr.Zero, IntPtr.Zero, primcount);
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_1_anh0000100(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; var count: Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first[0], count, primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000100(mode, start, &end, IntPtr.Zero, count, primcount);
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_2(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_2_anh0000100(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; count: IntPtr; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_2(mode, start, &end, first[0], count, primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_2_anh0000100(mode, start, &end, IntPtr.Zero, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count[0], primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_0_anh0000010(mode, start, &end, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; var count: Int32; primcount: Int32) :=
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: IntPtr; primcount: Int32) :=
z_MultiDrawRangeElementArrayAPPLE_ovr_2(mode, start, &end, first, count, primcount);
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_6(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_6_anh0000010(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawRangeElementArrayAPPLE_ovr_6(mode, start, &end, first, count[0], primcount) else
z_MultiDrawRangeElementArrayAPPLE_ovr_6_anh0000010(mode, start, &end, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32) :=
z_MultiDrawRangeElementArrayAPPLE_ovr_6(mode, start, &end, first, count, primcount);
private static procedure z_MultiDrawRangeElementArrayAPPLE_ovr_8(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawRangeElementArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32) :=
z_MultiDrawRangeElementArrayAPPLE_ovr_8(mode, start, &end, first, count, primcount);
end;
[PCUNotRestore]
glFenceAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenFencesAPPLE_ovr_0(n: Int32; var fences: UInt32);
external 'opengl32.dll' name 'glGenFencesAPPLE';
private static procedure z_GenFencesAPPLE_ovr_0_anh001(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glGenFencesAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; fences: array of UInt32) :=
if (fences<>nil) and (fences.Length<>0) then
z_GenFencesAPPLE_ovr_0(n, fences[0]) else
z_GenFencesAPPLE_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; var fences: UInt32) :=
z_GenFencesAPPLE_ovr_0(n, fences);
private static procedure z_GenFencesAPPLE_ovr_2(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glGenFencesAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; fences: IntPtr) :=
z_GenFencesAPPLE_ovr_2(n, fences);
private static procedure z_DeleteFencesAPPLE_ovr_0(n: Int32; var fences: UInt32);
external 'opengl32.dll' name 'glDeleteFencesAPPLE';
private static procedure z_DeleteFencesAPPLE_ovr_0_anh001(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glDeleteFencesAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; fences: array of UInt32) :=
if (fences<>nil) and (fences.Length<>0) then
z_DeleteFencesAPPLE_ovr_0(n, fences[0]) else
z_DeleteFencesAPPLE_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; var fences: UInt32) :=
z_DeleteFencesAPPLE_ovr_0(n, fences);
private static procedure z_DeleteFencesAPPLE_ovr_2(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glDeleteFencesAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; fences: IntPtr) :=
z_DeleteFencesAPPLE_ovr_2(n, fences);
private static procedure z_SetFenceAPPLE_ovr_0(fence: UInt32);
external 'opengl32.dll' name 'glSetFenceAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFenceAPPLE(fence: UInt32) :=
z_SetFenceAPPLE_ovr_0(fence);
private static function z_IsFenceAPPLE_ovr_0(fence: UInt32): boolean;
external 'opengl32.dll' name 'glIsFenceAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFenceAPPLE(fence: UInt32): boolean :=
z_IsFenceAPPLE_ovr_0(fence);
private static function z_TestFenceAPPLE_ovr_0(fence: UInt32): boolean;
external 'opengl32.dll' name 'glTestFenceAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestFenceAPPLE(fence: UInt32): boolean :=
z_TestFenceAPPLE_ovr_0(fence);
private static procedure z_FinishFenceAPPLE_ovr_0(fence: UInt32);
external 'opengl32.dll' name 'glFinishFenceAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishFenceAPPLE(fence: UInt32) :=
z_FinishFenceAPPLE_ovr_0(fence);
private static function z_TestObjectAPPLE_ovr_0(object: ObjectTypeAPPLE; name: UInt32): boolean;
external 'opengl32.dll' name 'glTestObjectAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestObjectAPPLE(object: ObjectTypeAPPLE; name: UInt32): boolean :=
z_TestObjectAPPLE_ovr_0(object, name);
private static procedure z_FinishObjectAPPLE_ovr_0(object: ObjectTypeAPPLE; name: Int32);
external 'opengl32.dll' name 'glFinishObjectAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishObjectAPPLE(object: ObjectTypeAPPLE; name: Int32) :=
z_FinishObjectAPPLE_ovr_0(object, name);
end;
[PCUNotRestore]
glFlushBufferRangeAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BufferParameteriAPPLE_ovr_0(target: DummyEnum; pname: DummyEnum; param: Int32);
external 'opengl32.dll' name 'glBufferParameteriAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferParameteriAPPLE(target: DummyEnum; pname: DummyEnum; param: Int32) :=
z_BufferParameteriAPPLE_ovr_0(target, pname, param);
private static procedure z_FlushMappedBufferRangeAPPLE_ovr_0(target: BufferTargetARB; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glFlushMappedBufferRangeAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRangeAPPLE(target: BufferTargetARB; offset: IntPtr; size: IntPtr) :=
z_FlushMappedBufferRangeAPPLE_ovr_0(target, offset, size);
end;
[PCUNotRestore]
glObjectPurgeableAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_ObjectPurgeableAPPLE_ovr_0(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum;
external 'opengl32.dll' name 'glObjectPurgeableAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ObjectPurgeableAPPLE(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum :=
z_ObjectPurgeableAPPLE_ovr_0(objectType, name, option);
private static function z_ObjectUnpurgeableAPPLE_ovr_0(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum;
external 'opengl32.dll' name 'glObjectUnpurgeableAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ObjectUnpurgeableAPPLE(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum :=
z_ObjectUnpurgeableAPPLE_ovr_0(objectType, name, option);
private static procedure z_GetObjectParameterivAPPLE_ovr_0(objectType: DummyEnum; name: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetObjectParameterivAPPLE';
private static procedure z_GetObjectParameterivAPPLE_ovr_0_anh00001(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterivAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetObjectParameterivAPPLE_ovr_0(objectType, name, pname, ¶ms[0]) else
z_GetObjectParameterivAPPLE_ovr_0_anh00001(objectType, name, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_GetObjectParameterivAPPLE_ovr_0(objectType, name, pname, ¶ms);
private static procedure z_GetObjectParameterivAPPLE_ovr_2(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterivAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetObjectParameterivAPPLE_ovr_2(objectType, name, pname, ¶ms);
end;
[PCUNotRestore]
glTextureRangeAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureRangeAPPLE_ovr_0(target: DummyEnum; length: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glTextureRangeAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureRangeAPPLE(target: DummyEnum; length: Int32; pointer: IntPtr) :=
z_TextureRangeAPPLE_ovr_0(target, length, pointer);
private static procedure z_GetTexParameterPointervAPPLE_ovr_0(target: DummyEnum; pname: DummyEnum; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterPointervAPPLE';
private static procedure z_GetTexParameterPointervAPPLE_ovr_0_anh0001(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterPointervAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterPointervAPPLE_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterPointervAPPLE_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; var ¶ms: IntPtr) :=
z_GetTexParameterPointervAPPLE_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameterPointervAPPLE_ovr_2(target: DummyEnum; pname: DummyEnum; ¶ms: pointer);
external 'opengl32.dll' name 'glGetTexParameterPointervAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; ¶ms: pointer) :=
z_GetTexParameterPointervAPPLE_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glVertexArrayObjectAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindVertexArrayAPPLE_ovr_0(&array: UInt32);
external 'opengl32.dll' name 'glBindVertexArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexArrayAPPLE(&array: UInt32) :=
z_BindVertexArrayAPPLE_ovr_0(&array);
private static procedure z_DeleteVertexArraysAPPLE_ovr_0(n: Int32; var arrays: UInt32);
external 'opengl32.dll' name 'glDeleteVertexArraysAPPLE';
private static procedure z_DeleteVertexArraysAPPLE_ovr_0_anh001(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glDeleteVertexArraysAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_DeleteVertexArraysAPPLE_ovr_0(n, arrays[0]) else
z_DeleteVertexArraysAPPLE_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; var arrays: UInt32) :=
z_DeleteVertexArraysAPPLE_ovr_0(n, arrays);
private static procedure z_DeleteVertexArraysAPPLE_ovr_2(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glDeleteVertexArraysAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; arrays: IntPtr) :=
z_DeleteVertexArraysAPPLE_ovr_2(n, arrays);
private static procedure z_GenVertexArraysAPPLE_ovr_0(n: Int32; var arrays: UInt32);
external 'opengl32.dll' name 'glGenVertexArraysAPPLE';
private static procedure z_GenVertexArraysAPPLE_ovr_0_anh001(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glGenVertexArraysAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_GenVertexArraysAPPLE_ovr_0(n, arrays[0]) else
z_GenVertexArraysAPPLE_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; var arrays: UInt32) :=
z_GenVertexArraysAPPLE_ovr_0(n, arrays);
private static procedure z_GenVertexArraysAPPLE_ovr_2(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glGenVertexArraysAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; arrays: IntPtr) :=
z_GenVertexArraysAPPLE_ovr_2(n, arrays);
private static function z_IsVertexArrayAPPLE_ovr_0(&array: UInt32): boolean;
external 'opengl32.dll' name 'glIsVertexArrayAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexArrayAPPLE(&array: UInt32): boolean :=
z_IsVertexArrayAPPLE_ovr_0(&array);
end;
[PCUNotRestore]
glVertexArrayRangeAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexArrayRangeAPPLE_ovr_0(length: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexArrayRangeAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayRangeAPPLE(length: Int32; pointer: IntPtr) :=
z_VertexArrayRangeAPPLE_ovr_0(length, pointer);
private static procedure z_FlushVertexArrayRangeAPPLE_ovr_0(length: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glFlushVertexArrayRangeAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushVertexArrayRangeAPPLE(length: Int32; pointer: IntPtr) :=
z_FlushVertexArrayRangeAPPLE_ovr_0(length, pointer);
private static procedure z_VertexArrayParameteriAPPLE_ovr_0(pname: VertexArrayPNameAPPLE; param: Int32);
external 'opengl32.dll' name 'glVertexArrayParameteriAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayParameteriAPPLE(pname: VertexArrayPNameAPPLE; param: Int32) :=
z_VertexArrayParameteriAPPLE_ovr_0(pname, param);
end;
[PCUNotRestore]
glVertexProgramEvaluatorsAPPLE = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_EnableVertexAttribAPPLE_ovr_0(index: UInt32; pname: DummyEnum);
external 'opengl32.dll' name 'glEnableVertexAttribAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribAPPLE(index: UInt32; pname: DummyEnum) :=
z_EnableVertexAttribAPPLE_ovr_0(index, pname);
private static procedure z_DisableVertexAttribAPPLE_ovr_0(index: UInt32; pname: DummyEnum);
external 'opengl32.dll' name 'glDisableVertexAttribAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribAPPLE(index: UInt32; pname: DummyEnum) :=
z_DisableVertexAttribAPPLE_ovr_0(index, pname);
private static function z_IsVertexAttribEnabledAPPLE_ovr_0(index: UInt32; pname: DummyEnum): boolean;
external 'opengl32.dll' name 'glIsVertexAttribEnabledAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexAttribEnabledAPPLE(index: UInt32; pname: DummyEnum): boolean :=
z_IsVertexAttribEnabledAPPLE_ovr_0(index, pname);
private static procedure z_MapVertexAttrib1dAPPLE_ovr_0(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; var points: real);
external 'opengl32.dll' name 'glMapVertexAttrib1dAPPLE';
private static procedure z_MapVertexAttrib1dAPPLE_ovr_0_anh00000001(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib1dAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: array of real) :=
if (points<>nil) and (points.Length<>0) then
z_MapVertexAttrib1dAPPLE_ovr_0(index, size, u1, u2, stride, order, points[0]) else
z_MapVertexAttrib1dAPPLE_ovr_0_anh00000001(index, size, u1, u2, stride, order, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; var points: real) :=
z_MapVertexAttrib1dAPPLE_ovr_0(index, size, u1, u2, stride, order, points);
private static procedure z_MapVertexAttrib1dAPPLE_ovr_2(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib1dAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr) :=
z_MapVertexAttrib1dAPPLE_ovr_2(index, size, u1, u2, stride, order, points);
private static procedure z_MapVertexAttrib1fAPPLE_ovr_0(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; var points: single);
external 'opengl32.dll' name 'glMapVertexAttrib1fAPPLE';
private static procedure z_MapVertexAttrib1fAPPLE_ovr_0_anh00000001(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib1fAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_MapVertexAttrib1fAPPLE_ovr_0(index, size, u1, u2, stride, order, points[0]) else
z_MapVertexAttrib1fAPPLE_ovr_0_anh00000001(index, size, u1, u2, stride, order, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; var points: single) :=
z_MapVertexAttrib1fAPPLE_ovr_0(index, size, u1, u2, stride, order, points);
private static procedure z_MapVertexAttrib1fAPPLE_ovr_2(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib1fAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr) :=
z_MapVertexAttrib1fAPPLE_ovr_2(index, size, u1, u2, stride, order, points);
private static procedure z_MapVertexAttrib2dAPPLE_ovr_0(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; var points: real);
external 'opengl32.dll' name 'glMapVertexAttrib2dAPPLE';
private static procedure z_MapVertexAttrib2dAPPLE_ovr_0_anh000000000001(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib2dAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: array of real) :=
if (points<>nil) and (points.Length<>0) then
z_MapVertexAttrib2dAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]) else
z_MapVertexAttrib2dAPPLE_ovr_0_anh000000000001(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; var points: real) :=
z_MapVertexAttrib2dAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_MapVertexAttrib2dAPPLE_ovr_2(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib2dAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr) :=
z_MapVertexAttrib2dAPPLE_ovr_2(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_MapVertexAttrib2fAPPLE_ovr_0(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; var points: single);
external 'opengl32.dll' name 'glMapVertexAttrib2fAPPLE';
private static procedure z_MapVertexAttrib2fAPPLE_ovr_0_anh000000000001(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib2fAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_MapVertexAttrib2fAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]) else
z_MapVertexAttrib2fAPPLE_ovr_0_anh000000000001(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; var points: single) :=
z_MapVertexAttrib2fAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_MapVertexAttrib2fAPPLE_ovr_2(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMapVertexAttrib2fAPPLE';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib2fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr) :=
z_MapVertexAttrib2fAPPLE_ovr_2(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
[PCUNotRestore]
glES2CompatibilityARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ReleaseShaderCompiler_ovr_0;
external 'opengl32.dll' name 'glReleaseShaderCompiler';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReleaseShaderCompiler :=
z_ReleaseShaderCompiler_ovr_0;
private static procedure z_ShaderBinary_ovr_0(count: Int32; var shaders: UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32);
external 'opengl32.dll' name 'glShaderBinary';
private static procedure z_ShaderBinary_ovr_0_anh001000(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32);
external 'opengl32.dll' name 'glShaderBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; shaders: array of UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
if (shaders<>nil) and (shaders.Length<>0) then
z_ShaderBinary_ovr_0(count, shaders[0], binaryformat, binary, length) else
z_ShaderBinary_ovr_0_anh001000(count, IntPtr.Zero, binaryformat, binary, length);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; var shaders: UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ShaderBinary_ovr_0(count, shaders, binaryformat, binary, length);
private static procedure z_ShaderBinary_ovr_2(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32);
external 'opengl32.dll' name 'glShaderBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; shaders: IntPtr; binaryformat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ShaderBinary_ovr_2(count, shaders, binaryformat, binary, length);
private static procedure z_GetShaderPrecisionFormat_ovr_0(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
private static procedure z_GetShaderPrecisionFormat_ovr_0_anh00010(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
private static procedure z_GetShaderPrecisionFormat_ovr_0_anh00001(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
private static procedure z_GetShaderPrecisionFormat_ovr_0_anh00011(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: array of Int32) :=
if (range<>nil) and (range.Length<>0) then
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00001(_shadertype, _precisiontype, range[0], IntPtr.Zero) else
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00011(_shadertype, _precisiontype, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetShaderPrecisionFormat_ovr_1_anh00010(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; var precision: Int32) :=
if (range<>nil) and (range.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision) else
z_GetShaderPrecisionFormat_ovr_0_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision);
private static procedure z_GetShaderPrecisionFormat_ovr_2(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
private static procedure z_GetShaderPrecisionFormat_ovr_2_anh00010(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: IntPtr) :=
if (range<>nil) and (range.Length<>0) then
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range[0], precision) else
z_GetShaderPrecisionFormat_ovr_2_anh00010(_shadertype, _precisiontype, IntPtr.Zero, precision);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: array of Int32) :=
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision[0]) else
z_GetShaderPrecisionFormat_ovr_0_anh00001(_shadertype, _precisiontype, range, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32) :=
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr) :=
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range, precision);
private static procedure z_GetShaderPrecisionFormat_ovr_6(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
private static procedure z_GetShaderPrecisionFormat_ovr_6_anh00001(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: array of Int32) :=
if (precision<>nil) and (precision.Length<>0) then
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision[0]) else
z_GetShaderPrecisionFormat_ovr_6_anh00001(_shadertype, _precisiontype, range, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32) :=
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision);
private static procedure z_GetShaderPrecisionFormat_ovr_8(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr);
external 'opengl32.dll' name 'glGetShaderPrecisionFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; precision: IntPtr) :=
z_GetShaderPrecisionFormat_ovr_8(_shadertype, _precisiontype, range, precision);
private static procedure z_DepthRangef_ovr_0(n: single; f: single);
external 'opengl32.dll' name 'glDepthRangef';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangef(n: single; f: single) :=
z_DepthRangef_ovr_0(n, f);
private static procedure z_ClearDepthf_ovr_0(d: single);
external 'opengl32.dll' name 'glClearDepthf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthf(d: single) :=
z_ClearDepthf_ovr_0(d);
end;
[PCUNotRestore]
glES31CompatibilityARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MemoryBarrierByRegion_ovr_0(barriers: MemoryBarrierMask);
external 'opengl32.dll' name 'glMemoryBarrierByRegion';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrierByRegion(barriers: MemoryBarrierMask) :=
z_MemoryBarrierByRegion_ovr_0(barriers);
end;
[PCUNotRestore]
glES32CompatibilityARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PrimitiveBoundingBoxARB_ovr_0(minX: single; minY: single; minZ: single; minW: single; maxX: single; maxY: single; maxZ: single; maxW: single);
external 'opengl32.dll' name 'glPrimitiveBoundingBoxARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveBoundingBoxARB(minX: single; minY: single; minZ: single; minW: single; maxX: single; maxY: single; maxZ: single; maxW: single) :=
z_PrimitiveBoundingBoxARB_ovr_0(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
end;
[PCUNotRestore]
glBaseInstanceARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawArraysInstancedBaseInstance_ovr_0(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32; baseinstance: UInt32);
external 'opengl32.dll' name 'glDrawArraysInstancedBaseInstance';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedBaseInstance(mode: PrimitiveType; first: Int32; count: Int32; instancecount: Int32; baseinstance: UInt32) :=
z_DrawArraysInstancedBaseInstance_ovr_0(mode, first, count, instancecount, baseinstance);
private static procedure z_DrawElementsInstancedBaseInstance_ovr_0(mode: PrimitiveType; count: Int32; &type: PrimitiveType; indices: IntPtr; instancecount: Int32; baseinstance: UInt32);
external 'opengl32.dll' name 'glDrawElementsInstancedBaseInstance';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseInstance(mode: PrimitiveType; count: Int32; &type: PrimitiveType; indices: IntPtr; instancecount: Int32; baseinstance: UInt32) :=
z_DrawElementsInstancedBaseInstance_ovr_0(mode, count, &type, indices, instancecount, baseinstance);
private static procedure z_DrawElementsInstancedBaseVertexBaseInstance_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32; baseinstance: UInt32);
external 'opengl32.dll' name 'glDrawElementsInstancedBaseVertexBaseInstance';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseVertexBaseInstance(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32; baseinstance: UInt32) :=
z_DrawElementsInstancedBaseVertexBaseInstance_ovr_0(mode, count, &type, indices, instancecount, basevertex, baseinstance);
end;
[PCUNotRestore]
glBindlessTextureARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetTextureHandleARB_ovr_0(texture: UInt32): UInt64;
external 'opengl32.dll' name 'glGetTextureHandleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureHandleARB(texture: UInt32): UInt64 :=
z_GetTextureHandleARB_ovr_0(texture);
private static function z_GetTextureSamplerHandleARB_ovr_0(texture: UInt32; sampler: UInt32): UInt64;
external 'opengl32.dll' name 'glGetTextureSamplerHandleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureSamplerHandleARB(texture: UInt32; sampler: UInt32): UInt64 :=
z_GetTextureSamplerHandleARB_ovr_0(texture, sampler);
private static procedure z_MakeTextureHandleResidentARB_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeTextureHandleResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleResidentARB(handle: UInt64) :=
z_MakeTextureHandleResidentARB_ovr_0(handle);
private static procedure z_MakeTextureHandleNonResidentARB_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeTextureHandleNonResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleNonResidentARB(handle: UInt64) :=
z_MakeTextureHandleNonResidentARB_ovr_0(handle);
private static function z_GetImageHandleARB_ovr_0(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64;
external 'opengl32.dll' name 'glGetImageHandleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetImageHandleARB(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64 :=
z_GetImageHandleARB_ovr_0(texture, level, layered, layer, format);
private static procedure z_MakeImageHandleResidentARB_ovr_0(handle: UInt64; access: DummyEnum);
external 'opengl32.dll' name 'glMakeImageHandleResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleResidentARB(handle: UInt64; access: DummyEnum) :=
z_MakeImageHandleResidentARB_ovr_0(handle, access);
private static procedure z_MakeImageHandleNonResidentARB_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeImageHandleNonResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleNonResidentARB(handle: UInt64) :=
z_MakeImageHandleNonResidentARB_ovr_0(handle);
private static procedure z_UniformHandleui64ARB_ovr_0(location: Int32; value: UInt64);
external 'opengl32.dll' name 'glUniformHandleui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64ARB(location: Int32; value: UInt64) :=
z_UniformHandleui64ARB_ovr_0(location, value);
private static procedure z_UniformHandleui64vARB_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniformHandleui64vARB';
private static procedure z_UniformHandleui64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformHandleui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_UniformHandleui64vARB_ovr_0(location, count, value[0]) else
z_UniformHandleui64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; var value: UInt64) :=
z_UniformHandleui64vARB_ovr_0(location, count, value);
private static procedure z_UniformHandleui64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformHandleui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_UniformHandleui64vARB_ovr_2(location, count, value);
private static procedure z_ProgramUniformHandleui64ARB_ovr_0(&program: UInt32; location: Int32; value: UInt64);
external 'opengl32.dll' name 'glProgramUniformHandleui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64ARB(&program: UInt32; location: Int32; value: UInt64) :=
z_ProgramUniformHandleui64ARB_ovr_0(&program, location, value);
private static procedure z_ProgramUniformHandleui64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var values: UInt64);
external 'opengl32.dll' name 'glProgramUniformHandleui64vARB';
private static procedure z_ProgramUniformHandleui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
external 'opengl32.dll' name 'glProgramUniformHandleui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; values: array of UInt64) :=
if (values<>nil) and (values.Length<>0) then
z_ProgramUniformHandleui64vARB_ovr_0(&program, location, count, values[0]) else
z_ProgramUniformHandleui64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; var values: UInt64) :=
z_ProgramUniformHandleui64vARB_ovr_0(&program, location, count, values);
private static procedure z_ProgramUniformHandleui64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
external 'opengl32.dll' name 'glProgramUniformHandleui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; values: IntPtr) :=
z_ProgramUniformHandleui64vARB_ovr_2(&program, location, count, values);
private static function z_IsTextureHandleResidentARB_ovr_0(handle: UInt64): boolean;
external 'opengl32.dll' name 'glIsTextureHandleResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureHandleResidentARB(handle: UInt64): boolean :=
z_IsTextureHandleResidentARB_ovr_0(handle);
private static function z_IsImageHandleResidentARB_ovr_0(handle: UInt64): boolean;
external 'opengl32.dll' name 'glIsImageHandleResidentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsImageHandleResidentARB(handle: UInt64): boolean :=
z_IsImageHandleResidentARB_ovr_0(handle);
private static procedure z_VertexAttribL1ui64ARB_ovr_0(index: UInt32; x: UInt64);
external 'opengl32.dll' name 'glVertexAttribL1ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64ARB(index: UInt32; x: UInt64) :=
z_VertexAttribL1ui64ARB_ovr_0(index, x);
private static procedure z_VertexAttribL1ui64vARB_ovr_0(index: UInt32; var v: UInt64);
external 'opengl32.dll' name 'glVertexAttribL1ui64vARB';
private static procedure z_VertexAttribL1ui64vARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; v: array of UInt64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1ui64vARB_ovr_0(index, v[0]) else
z_VertexAttribL1ui64vARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; var v: UInt64) :=
z_VertexAttribL1ui64vARB_ovr_0(index, v);
private static procedure z_VertexAttribL1ui64vARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; v: IntPtr) :=
z_VertexAttribL1ui64vARB_ovr_2(index, v);
private static procedure z_GetVertexAttribLui64vARB_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetVertexAttribLui64vARB';
private static procedure z_GetVertexAttribLui64vARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLui64vARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLui64vARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64) :=
z_GetVertexAttribLui64vARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribLui64vARB_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLui64vARB_ovr_2(index, pname, ¶ms);
end;
[PCUNotRestore]
glBlendFuncExtendedARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindFragDataLocationIndexed_ovr_0(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: IntPtr);
external 'opengl32.dll' name 'glBindFragDataLocationIndexed';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationIndexed(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindFragDataLocationIndexed_ovr_0(&program, colorNumber, index, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationIndexed(&program: ProgramName; colorNumber: UInt32; index: UInt32; name: IntPtr) :=
z_BindFragDataLocationIndexed_ovr_0(&program, colorNumber, index, name);
private static function z_GetFragDataIndex_ovr_0(&program: ProgramName; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetFragDataIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataIndex(&program: ProgramName; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetFragDataIndex_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataIndex(&program: ProgramName; name: IntPtr): Int32 :=
z_GetFragDataIndex_ovr_0(&program, name);
end;
[PCUNotRestore]
glBufferStorageARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BufferStorage_ovr_0(target: BufferStorageTarget; size: IntPtr; data: IntPtr; flags: BufferStorageMask);
external 'opengl32.dll' name 'glBufferStorage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorage(target: BufferStorageTarget; size: IntPtr; data: IntPtr; flags: BufferStorageMask) :=
z_BufferStorage_ovr_0(target, size, data, flags);
end;
[PCUNotRestore]
glClEventARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_CreateSyncFromCLeventARB_ovr_0(var context: cl_context; var &event: cl_event; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
private static function z_CreateSyncFromCLeventARB_ovr_0_anh0100(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
private static function z_CreateSyncFromCLeventARB_ovr_0_anh0010(var context: cl_context; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
private static function z_CreateSyncFromCLeventARB_ovr_0_anh0110(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; &event: array of cl_event; flags: DummyFlags): GLsync :=
if (context<>nil) and (context.Length<>0) then
if (&event<>nil) and (&event.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_0(context[0], &event[0], flags) else
z_CreateSyncFromCLeventARB_ovr_0_anh0010(context[0], IntPtr.Zero, flags) else
if (&event<>nil) and (&event.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_0_anh0100(IntPtr.Zero, &event[0], flags) else
z_CreateSyncFromCLeventARB_ovr_0_anh0110(IntPtr.Zero, IntPtr.Zero, flags);
private static function z_CreateSyncFromCLeventARB_ovr_1_anh0100(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; var &event: cl_event; flags: DummyFlags): GLsync :=
if (context<>nil) and (context.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_0(context[0], &event, flags) else
z_CreateSyncFromCLeventARB_ovr_0_anh0100(IntPtr.Zero, &event, flags);
private static function z_CreateSyncFromCLeventARB_ovr_2(var context: cl_context; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
private static function z_CreateSyncFromCLeventARB_ovr_2_anh0100(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; &event: IntPtr; flags: DummyFlags): GLsync :=
if (context<>nil) and (context.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_2(context[0], &event, flags) else
z_CreateSyncFromCLeventARB_ovr_2_anh0100(IntPtr.Zero, &event, flags);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; &event: array of cl_event; flags: DummyFlags): GLsync :=
if (&event<>nil) and (&event.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_0(context, &event[0], flags) else
z_CreateSyncFromCLeventARB_ovr_0_anh0010(context, IntPtr.Zero, flags);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; var &event: cl_event; flags: DummyFlags): GLsync :=
z_CreateSyncFromCLeventARB_ovr_0(context, &event, flags);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; &event: IntPtr; flags: DummyFlags): GLsync :=
z_CreateSyncFromCLeventARB_ovr_2(context, &event, flags);
private static function z_CreateSyncFromCLeventARB_ovr_6(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
private static function z_CreateSyncFromCLeventARB_ovr_6_anh0010(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; &event: array of cl_event; flags: DummyFlags): GLsync :=
if (&event<>nil) and (&event.Length<>0) then
z_CreateSyncFromCLeventARB_ovr_6(context, &event[0], flags) else
z_CreateSyncFromCLeventARB_ovr_6_anh0010(context, IntPtr.Zero, flags);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync :=
z_CreateSyncFromCLeventARB_ovr_6(context, &event, flags);
private static function z_CreateSyncFromCLeventARB_ovr_8(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glCreateSyncFromCLeventARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync :=
z_CreateSyncFromCLeventARB_ovr_8(context, &event, flags);
end;
[PCUNotRestore]
glClearBufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ClearBufferData_ovr_0(target: BufferStorageTarget; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearBufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferData(target: BufferStorageTarget; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearBufferData_ovr_0(target, _internalformat, format, &type, data);
private static procedure z_ClearBufferSubData_ovr_0(target: BufferTargetARB; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTargetARB; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearBufferSubData_ovr_0(target, _internalformat, offset, size, format, &type, data);
end;
[PCUNotRestore]
glClearTextureARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ClearTexImage_ovr_0(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearTexImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearTexImage(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearTexImage_ovr_0(texture, level, format, &type, data);
private static procedure z_ClearTexSubImage_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearTexSubImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearTexSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, data);
end;
[PCUNotRestore]
glClipControlARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ClipControl_ovr_0(origin: ClipControlOrigin; depth: ClipControlDepth);
external 'opengl32.dll' name 'glClipControl';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipControl(origin: ClipControlOrigin; depth: ClipControlDepth) :=
z_ClipControl_ovr_0(origin, depth);
end;
[PCUNotRestore]
glColorBufferFloatARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ClampColorARB_ovr_0(target: ClampColorTargetARB; clamp: ClampColorModeARB);
external 'opengl32.dll' name 'glClampColorARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClampColorARB(target: ClampColorTargetARB; clamp: ClampColorModeARB) :=
z_ClampColorARB_ovr_0(target, clamp);
end;
[PCUNotRestore]
glComputeShaderARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DispatchCompute_ovr_0(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32);
external 'opengl32.dll' name 'glDispatchCompute';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchCompute(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32) :=
z_DispatchCompute_ovr_0(num_groups_x, num_groups_y, num_groups_z);
private static procedure z_DispatchComputeIndirect_ovr_0(indirect: IntPtr);
external 'opengl32.dll' name 'glDispatchComputeIndirect';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchComputeIndirect(indirect: IntPtr) :=
z_DispatchComputeIndirect_ovr_0(indirect);
end;
[PCUNotRestore]
glComputeVariableGroupSizeARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DispatchComputeGroupSizeARB_ovr_0(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32; group_size_x: UInt32; group_size_y: UInt32; group_size_z: UInt32);
external 'opengl32.dll' name 'glDispatchComputeGroupSizeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchComputeGroupSizeARB(num_groups_x: UInt32; num_groups_y: UInt32; num_groups_z: UInt32; group_size_x: UInt32; group_size_y: UInt32; group_size_z: UInt32) :=
z_DispatchComputeGroupSizeARB_ovr_0(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
end;
[PCUNotRestore]
glCopyBufferARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CopyBufferSubData_ovr_0(readTarget: CopyBufferSubDataTarget; writeTarget: CopyBufferSubDataTarget; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glCopyBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyBufferSubData(readTarget: CopyBufferSubDataTarget; writeTarget: CopyBufferSubDataTarget; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_CopyBufferSubData_ovr_0(readTarget, writeTarget, readOffset, writeOffset, size);
end;
[PCUNotRestore]
glCopyImageARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CopyImageSubData_ovr_0(srcName: UInt32; srcTarget: CopyImageSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyImageSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32);
external 'opengl32.dll' name 'glCopyImageSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyImageSubData(srcName: UInt32; srcTarget: CopyImageSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyImageSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32) :=
z_CopyImageSubData_ovr_0(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
end;
[PCUNotRestore]
glDebugOutputARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DebugMessageControlARB_ovr_0(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControlARB';
private static procedure z_DebugMessageControlARB_ovr_0_anh0000010(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControlARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean) :=
if (ids<>nil) and (ids.Length<>0) then
z_DebugMessageControlARB_ovr_0(source, &type, severity, count, ids[0], enabled) else
z_DebugMessageControlARB_ovr_0_anh0000010(source, &type, severity, count, IntPtr.Zero, enabled);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean) :=
z_DebugMessageControlARB_ovr_0(source, &type, severity, count, ids, enabled);
private static procedure z_DebugMessageControlARB_ovr_2(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControlARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean) :=
z_DebugMessageControlARB_ovr_2(source, &type, severity, count, ids, enabled);
private static procedure z_DebugMessageInsertARB_ovr_0(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr);
external 'opengl32.dll' name 'glDebugMessageInsertARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsertARB(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: string);
begin
var par_6_str_ptr := Marshal.StringToHGlobalAnsi(buf);
z_DebugMessageInsertARB_ovr_0(source, &type, id, severity, length, par_6_str_ptr);
Marshal.FreeHGlobal(par_6_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsertARB(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr) :=
z_DebugMessageInsertARB_ovr_0(source, &type, id, severity, length, buf);
private static procedure z_DebugMessageCallbackARB_ovr_0(callback: GLDEBUGPROC; userParam: IntPtr);
external 'opengl32.dll' name 'glDebugMessageCallbackARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallbackARB(callback: GLDEBUGPROC; userParam: IntPtr) :=
z_DebugMessageCallbackARB_ovr_0(callback, userParam);
private static function z_GetDebugMessageLogARB_ovr_0(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLogARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogARB(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLogARB_ovr_0(count, bufSize, sources, types, ids, severities, lengths, messageLog);
private static function z_GetDebugMessageLogARB_ovr_1(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLogARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogARB(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLogARB_ovr_1(count, bufSize, sources, types, ids, severities, lengths, messageLog);
end;
[PCUNotRestore]
glDirectStateAccessARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CreateTransformFeedbacks_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glCreateTransformFeedbacks';
private static procedure z_CreateTransformFeedbacks_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glCreateTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_CreateTransformFeedbacks_ovr_0(n, ids[0]) else
z_CreateTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_CreateTransformFeedbacks_ovr_0(n, ids);
private static procedure z_CreateTransformFeedbacks_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glCreateTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_CreateTransformFeedbacks_ovr_2(n, ids);
private static procedure z_TransformFeedbackBufferBase_ovr_0(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName);
external 'opengl32.dll' name 'glTransformFeedbackBufferBase';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackBufferBase(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName) :=
z_TransformFeedbackBufferBase_ovr_0(xfb, index, buffer);
private static procedure z_TransformFeedbackBufferRange_ovr_0(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glTransformFeedbackBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackBufferRange(xfb: TransformFeedbackName; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TransformFeedbackBufferRange_ovr_0(xfb, index, buffer, offset, size);
private static procedure z_GetTransformFeedbackiv_ovr_0(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32);
external 'opengl32.dll' name 'glGetTransformFeedbackiv';
private static procedure z_GetTransformFeedbackiv_ovr_0_anh0001(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param[0]) else
z_GetTransformFeedbackiv_ovr_0_anh0001(xfb, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32) :=
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param);
private static procedure z_GetTransformFeedbackiv_ovr_2(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; param: IntPtr) :=
z_GetTransformFeedbackiv_ovr_2(xfb, pname, param);
private static procedure z_GetTransformFeedbacki_v_ovr_0(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32);
external 'opengl32.dll' name 'glGetTransformFeedbacki_v';
private static procedure z_GetTransformFeedbacki_v_ovr_0_anh00001(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbacki_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param[0]) else
z_GetTransformFeedbacki_v_ovr_0_anh00001(xfb, pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32) :=
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param);
private static procedure z_GetTransformFeedbacki_v_ovr_2(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbacki_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr) :=
z_GetTransformFeedbacki_v_ovr_2(xfb, pname, index, param);
private static procedure z_GetTransformFeedbacki64_v_ovr_0(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64);
external 'opengl32.dll' name 'glGetTransformFeedbacki64_v';
private static procedure z_GetTransformFeedbacki64_v_ovr_0_anh00001(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbacki64_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int64) :=
if (param<>nil) and (param.Length<>0) then
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param[0]) else
z_GetTransformFeedbacki64_v_ovr_0_anh00001(xfb, pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64) :=
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param);
private static procedure z_GetTransformFeedbacki64_v_ovr_2(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbacki64_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: IntPtr) :=
z_GetTransformFeedbacki64_v_ovr_2(xfb, pname, index, param);
private static procedure z_CreateBuffers_ovr_0(n: Int32; var buffers: BufferName);
external 'opengl32.dll' name 'glCreateBuffers';
private static procedure z_CreateBuffers_ovr_0_anh001(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glCreateBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: array of BufferName) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_CreateBuffers_ovr_0(n, buffers[0]) else
z_CreateBuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; var buffers: BufferName) :=
z_CreateBuffers_ovr_0(n, buffers);
private static procedure z_CreateBuffers_ovr_2(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glCreateBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: IntPtr) :=
z_CreateBuffers_ovr_2(n, buffers);
private static procedure z_NamedBufferStorage_ovr_0(buffer: BufferName; size: IntPtr; data: IntPtr; flags: BufferStorageMask);
external 'opengl32.dll' name 'glNamedBufferStorage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorage(buffer: BufferName; size: IntPtr; data: IntPtr; flags: BufferStorageMask) :=
z_NamedBufferStorage_ovr_0(buffer, size, data, flags);
private static procedure z_NamedBufferData_ovr_0(buffer: BufferName; size: IntPtr; var data: Byte; usage: VertexBufferObjectUsage);
external 'opengl32.dll' name 'glNamedBufferData';
private [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure temp_NamedBufferData_ovr_0<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage); where T: record;
begin
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
end;
private [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure temp_NamedBufferData_ovr_0_anh00010(buffer: BufferName; size: IntPtr; usage: VertexBufferObjectUsage) :=
z_NamedBufferData_ovr_0(buffer, size, PByte(nil)^, usage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; data: array of T; usage: VertexBufferObjectUsage); where T: record;
begin
if (data<>nil) and (data.Length<>0) then
temp_NamedBufferData_ovr_0(buffer, size, data[0], usage) else
temp_NamedBufferData_ovr_0_anh00010(buffer, size, usage);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage); where T: record;
begin
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
end;
private static procedure z_NamedBufferData_ovr_2(buffer: BufferName; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage);
external 'opengl32.dll' name 'glNamedBufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData(buffer: BufferName; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage) :=
z_NamedBufferData_ovr_2(buffer, size, data, usage);
private static procedure z_NamedBufferSubData_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glNamedBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_NamedBufferSubData_ovr_0(buffer, offset, size, data);
private static procedure z_CopyNamedBufferSubData_ovr_0(readBuffer: BufferName; writeBuffer: BufferName; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glCopyNamedBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyNamedBufferSubData(readBuffer: BufferName; writeBuffer: BufferName; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_CopyNamedBufferSubData_ovr_0(readBuffer, writeBuffer, readOffset, writeOffset, size);
private static procedure z_ClearNamedBufferData_ovr_0(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearNamedBufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferData(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferData_ovr_0(buffer, _internalformat, format, &type, data);
private static procedure z_ClearNamedBufferSubData_ovr_0(buffer: UInt32; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearNamedBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferSubData(buffer: UInt32; _internalformat: InternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferSubData_ovr_0(buffer, _internalformat, offset, size, format, &type, data);
private static function z_MapNamedBuffer_ovr_0(buffer: BufferName; access: BufferAccessARB): IntPtr;
external 'opengl32.dll' name 'glMapNamedBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBuffer(buffer: BufferName; access: BufferAccessARB): IntPtr :=
z_MapNamedBuffer_ovr_0(buffer, access);
private static function z_MapNamedBufferRange_ovr_0(buffer: BufferName; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr;
external 'opengl32.dll' name 'glMapNamedBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferRange(buffer: BufferName; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
z_MapNamedBufferRange_ovr_0(buffer, offset, length, access);
private static function z_UnmapNamedBuffer_ovr_0(buffer: BufferName): boolean;
external 'opengl32.dll' name 'glUnmapNamedBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapNamedBuffer(buffer: BufferName): boolean :=
z_UnmapNamedBuffer_ovr_0(buffer);
private static procedure z_FlushMappedNamedBufferRange_ovr_0(buffer: BufferName; offset: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glFlushMappedNamedBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedNamedBufferRange(buffer: BufferName; offset: IntPtr; length: IntPtr) :=
z_FlushMappedNamedBufferRange_ovr_0(buffer, offset, length);
private static procedure z_GetNamedBufferParameteriv_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedBufferParameteriv';
private static procedure z_GetNamedBufferParameteriv_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameteriv_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32) :=
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferParameteriv_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameteriv_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferParameteri64v_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetNamedBufferParameteri64v';
private static procedure z_GetNamedBufferParameteri64v_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameteri64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameteri64v_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64) :=
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferParameteri64v_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameteri64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameteri64v_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferPointerv_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferPointerv';
private static procedure z_GetNamedBufferPointerv_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferPointerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferPointerv_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr) :=
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferPointerv_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer);
external 'opengl32.dll' name 'glGetNamedBufferPointerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer) :=
z_GetNamedBufferPointerv_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferSubData_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_GetNamedBufferSubData_ovr_0(buffer, offset, size, data);
private static procedure z_CreateFramebuffers_ovr_0(n: Int32; var framebuffers: UInt32);
external 'opengl32.dll' name 'glCreateFramebuffers';
private static procedure z_CreateFramebuffers_ovr_0_anh001(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glCreateFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_CreateFramebuffers_ovr_0(n, framebuffers[0]) else
z_CreateFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_CreateFramebuffers_ovr_0(n, framebuffers);
private static procedure z_CreateFramebuffers_ovr_2(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glCreateFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_CreateFramebuffers_ovr_2(n, framebuffers);
private static procedure z_NamedFramebufferRenderbuffer_ovr_0(framebuffer: FramebufferName; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName);
external 'opengl32.dll' name 'glNamedFramebufferRenderbuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferRenderbuffer(framebuffer: FramebufferName; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_NamedFramebufferRenderbuffer_ovr_0(framebuffer, attachment, _renderbuffertarget, renderbuffer);
private static procedure z_NamedFramebufferParameteri_ovr_0(framebuffer: FramebufferName; pname: FramebufferParameterName; param: Int32);
external 'opengl32.dll' name 'glNamedFramebufferParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferParameteri(framebuffer: FramebufferName; pname: FramebufferParameterName; param: Int32) :=
z_NamedFramebufferParameteri_ovr_0(framebuffer, pname, param);
private static procedure z_NamedFramebufferTexture_ovr_0(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTexture';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32) :=
z_NamedFramebufferTexture_ovr_0(framebuffer, attachment, texture, level);
private static procedure z_NamedFramebufferTextureLayer_ovr_0(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTextureLayer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureLayer(framebuffer: FramebufferName; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32) :=
z_NamedFramebufferTextureLayer_ovr_0(framebuffer, attachment, texture, level, layer);
private static procedure z_NamedFramebufferDrawBuffer_ovr_0(framebuffer: FramebufferName; buf: ColorBuffer);
external 'opengl32.dll' name 'glNamedFramebufferDrawBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffer(framebuffer: FramebufferName; buf: ColorBuffer) :=
z_NamedFramebufferDrawBuffer_ovr_0(framebuffer, buf);
private static procedure z_NamedFramebufferDrawBuffers_ovr_0(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer);
external 'opengl32.dll' name 'glNamedFramebufferDrawBuffers';
private static procedure z_NamedFramebufferDrawBuffers_ovr_0_anh0001(framebuffer: UInt32; n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferDrawBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; bufs: array of ColorBuffer) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs[0]) else
z_NamedFramebufferDrawBuffers_ovr_0_anh0001(framebuffer, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer) :=
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs);
private static procedure z_NamedFramebufferDrawBuffers_ovr_2(framebuffer: UInt32; n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferDrawBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; bufs: IntPtr) :=
z_NamedFramebufferDrawBuffers_ovr_2(framebuffer, n, bufs);
private static procedure z_NamedFramebufferReadBuffer_ovr_0(framebuffer: FramebufferName; src: ColorBuffer);
external 'opengl32.dll' name 'glNamedFramebufferReadBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferReadBuffer(framebuffer: FramebufferName; src: ColorBuffer) :=
z_NamedFramebufferReadBuffer_ovr_0(framebuffer, src);
private static procedure z_InvalidateNamedFramebufferData_ovr_0(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferData';
private static procedure z_InvalidateNamedFramebufferData_ovr_0_anh0001(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; attachments: array of FramebufferAttachment) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments[0]) else
z_InvalidateNamedFramebufferData_ovr_0_anh0001(framebuffer, numAttachments, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment) :=
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments);
private static procedure z_InvalidateNamedFramebufferData_ovr_2(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr) :=
z_InvalidateNamedFramebufferData_ovr_2(framebuffer, numAttachments, attachments);
private static procedure z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferSubData';
private static procedure z_InvalidateNamedFramebufferSubData_ovr_0_anh00010000(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; attachments: array of FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments[0], x, y, width, height) else
z_InvalidateNamedFramebufferSubData_ovr_0_anh00010000(framebuffer, numAttachments, IntPtr.Zero, x, y, width, height);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments, x, y, width, height);
private static procedure z_InvalidateNamedFramebufferSubData_ovr_2(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateNamedFramebufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateNamedFramebufferSubData_ovr_2(framebuffer, numAttachments, attachments, x, y, width, height);
private static procedure z_ClearNamedFramebufferiv_ovr_0(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32);
external 'opengl32.dll' name 'glClearNamedFramebufferiv';
private static procedure z_ClearNamedFramebufferiv_ovr_0_anh00001(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferiv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32) :=
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferiv_ovr_2(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferuiv_ovr_0(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32);
external 'opengl32.dll' name 'glClearNamedFramebufferuiv';
private static procedure z_ClearNamedFramebufferuiv_ovr_0_anh00001(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferuiv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32) :=
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferuiv_ovr_2(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferuiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferfv_ovr_0(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single);
external 'opengl32.dll' name 'glClearNamedFramebufferfv';
private static procedure z_ClearNamedFramebufferfv_ovr_0_anh00001(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]) else
z_ClearNamedFramebufferfv_ovr_0_anh00001(framebuffer, _buffer, drawbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single) :=
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferfv_ovr_2(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr);
external 'opengl32.dll' name 'glClearNamedFramebufferfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: IntPtr) :=
z_ClearNamedFramebufferfv_ovr_2(framebuffer, _buffer, drawbuffer, value);
private static procedure z_ClearNamedFramebufferfi_ovr_0(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32);
external 'opengl32.dll' name 'glClearNamedFramebufferfi';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfi(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; depth: single; stencil: Int32) :=
z_ClearNamedFramebufferfi_ovr_0(framebuffer, _buffer, drawbuffer, depth, stencil);
private static procedure z_BlitNamedFramebuffer_ovr_0(readFramebuffer: UInt32; drawFramebuffer: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter);
external 'opengl32.dll' name 'glBlitNamedFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlitNamedFramebuffer(readFramebuffer: UInt32; drawFramebuffer: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter) :=
z_BlitNamedFramebuffer_ovr_0(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
private static function z_CheckNamedFramebufferStatus_ovr_0(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus;
external 'opengl32.dll' name 'glCheckNamedFramebufferStatus';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckNamedFramebufferStatus(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus :=
z_CheckNamedFramebufferStatus_ovr_0(framebuffer, target);
private static procedure z_GetNamedFramebufferParameteriv_ovr_0(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32);
external 'opengl32.dll' name 'glGetNamedFramebufferParameteriv';
private static procedure z_GetNamedFramebufferParameteriv_ovr_0_anh0001(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param[0]) else
z_GetNamedFramebufferParameteriv_ovr_0_anh0001(framebuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32) :=
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param);
private static procedure z_GetNamedFramebufferParameteriv_ovr_2(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; param: IntPtr) :=
z_GetNamedFramebufferParameteriv_ovr_2(framebuffer, pname, param);
private static procedure z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameteriv';
private static procedure z_GetNamedFramebufferAttachmentParameteriv_ovr_0_anh00001(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms[0]) else
z_GetNamedFramebufferAttachmentParameteriv_ovr_0_anh00001(framebuffer, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms);
private static procedure z_GetNamedFramebufferAttachmentParameteriv_ovr_2(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetNamedFramebufferAttachmentParameteriv_ovr_2(framebuffer, attachment, pname, ¶ms);
private static procedure z_CreateRenderbuffers_ovr_0(n: Int32; var renderbuffers: UInt32);
external 'opengl32.dll' name 'glCreateRenderbuffers';
private static procedure z_CreateRenderbuffers_ovr_0_anh001(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glCreateRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_CreateRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_CreateRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_CreateRenderbuffers_ovr_0(n, renderbuffers);
private static procedure z_CreateRenderbuffers_ovr_2(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glCreateRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_CreateRenderbuffers_ovr_2(n, renderbuffers);
private static procedure z_NamedRenderbufferStorage_ovr_0(renderbuffer: RenderbufferName; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorage(renderbuffer: RenderbufferName; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorage_ovr_0(renderbuffer, _internalformat, width, height);
private static procedure z_NamedRenderbufferStorageMultisample_ovr_0(renderbuffer: RenderbufferName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorageMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisample(renderbuffer: RenderbufferName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageMultisample_ovr_0(renderbuffer, samples, _internalformat, width, height);
private static procedure z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameteriv';
private static procedure z_GetNamedRenderbufferParameteriv_ovr_0_anh0001(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms[0]) else
z_GetNamedRenderbufferParameteriv_ovr_0_anh0001(renderbuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms);
private static procedure z_GetNamedRenderbufferParameteriv_ovr_2(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetNamedRenderbufferParameteriv_ovr_2(renderbuffer, pname, ¶ms);
private static procedure z_CreateTextures_ovr_0(target: TextureTarget; n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glCreateTextures';
private static procedure z_CreateTextures_ovr_0_anh0001(target: TextureTarget; n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glCreateTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_CreateTextures_ovr_0(target, n, textures[0]) else
z_CreateTextures_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; var textures: UInt32) :=
z_CreateTextures_ovr_0(target, n, textures);
private static procedure z_CreateTextures_ovr_2(target: TextureTarget; n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glCreateTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; textures: IntPtr) :=
z_CreateTextures_ovr_2(target, n, textures);
private static procedure z_TextureBuffer_ovr_0(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName);
external 'opengl32.dll' name 'glTextureBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBuffer(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName) :=
z_TextureBuffer_ovr_0(texture, _internalformat, buffer);
private static procedure z_TextureBufferRange_ovr_0(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glTextureBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferRange(texture: TextureName; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TextureBufferRange_ovr_0(texture, _internalformat, buffer, offset, size);
private static procedure z_TextureStorage1D_ovr_0(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32);
external 'opengl32.dll' name 'glTextureStorage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage1D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32) :=
z_TextureStorage1D_ovr_0(texture, levels, _internalformat, width);
private static procedure z_TextureStorage2D_ovr_0(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glTextureStorage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_TextureStorage2D_ovr_0(texture, levels, _internalformat, width, height);
private static procedure z_TextureStorage3D_ovr_0(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glTextureStorage3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3D(texture: TextureName; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32) :=
z_TextureStorage3D_ovr_0(texture, levels, _internalformat, width, height, depth);
private static procedure z_TextureStorage2DMultisample_ovr_0(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTextureStorage2DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DMultisample(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage2DMultisample_ovr_0(texture, samples, _internalformat, width, height, fixedsamplelocations);
private static procedure z_TextureStorage3DMultisample_ovr_0(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTextureStorage3DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DMultisample(texture: TextureName; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage3DMultisample_ovr_0(texture, samples, _internalformat, width, height, depth, fixedsamplelocations);
private static procedure z_TextureSubImage1D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage1D(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage1D_ovr_0(texture, level, xoffset, width, format, &type, pixels);
private static procedure z_TextureSubImage2D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage2D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, &type, pixels);
private static procedure z_TextureSubImage3D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage3D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
private static procedure z_CompressedTextureSubImage1D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage1D(texture: UInt32; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage1D_ovr_0(texture, level, xoffset, width, format, imageSize, data);
private static procedure z_CompressedTextureSubImage2D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage2D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
private static procedure z_CompressedTextureSubImage3D_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage3D(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
private static procedure z_CopyTextureSubImage1D_ovr_0(texture: TextureName; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage1D(texture: TextureName; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyTextureSubImage1D_ovr_0(texture, level, xoffset, x, y, width);
private static procedure z_CopyTextureSubImage2D_ovr_0(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage2D(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, x, y, width, height);
private static procedure z_CopyTextureSubImage3D_ovr_0(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage3D(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
private static procedure z_TextureParameterf_ovr_0(texture: TextureName; pname: TextureParameterName; param: single);
external 'opengl32.dll' name 'glTextureParameterf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterf(texture: TextureName; pname: TextureParameterName; param: single) :=
z_TextureParameterf_ovr_0(texture, pname, param);
private static procedure z_TextureParameterfv_ovr_0(texture: UInt32; pname: TextureParameterName; var param: single);
external 'opengl32.dll' name 'glTextureParameterfv';
private static procedure z_TextureParameterfv_ovr_0_anh0001(texture: UInt32; pname: TextureParameterName; param: IntPtr);
external 'opengl32.dll' name 'glTextureParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_TextureParameterfv_ovr_0(texture, pname, param[0]) else
z_TextureParameterfv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; var param: single) :=
z_TextureParameterfv_ovr_0(texture, pname, param);
private static procedure z_TextureParameterfv_ovr_2(texture: UInt32; pname: TextureParameterName; param: IntPtr);
external 'opengl32.dll' name 'glTextureParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; param: IntPtr) :=
z_TextureParameterfv_ovr_2(texture, pname, param);
private static procedure z_TextureParameteri_ovr_0(texture: UInt32; pname: TextureParameterName; param: Int32);
external 'opengl32.dll' name 'glTextureParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteri(texture: UInt32; pname: TextureParameterName; param: Int32) :=
z_TextureParameteri_ovr_0(texture, pname, param);
private static procedure z_TextureParameterIiv_ovr_0(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTextureParameterIiv';
private static procedure z_TextureParameterIiv_ovr_0_anh0001(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms[0]) else
z_TextureParameterIiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32) :=
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms);
private static procedure z_TextureParameterIiv_ovr_2(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIiv_ovr_2(texture, pname, ¶ms);
private static procedure z_TextureParameterIuiv_ovr_0(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32);
external 'opengl32.dll' name 'glTextureParameterIuiv';
private static procedure z_TextureParameterIuiv_ovr_0_anh0001(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]) else
z_TextureParameterIuiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32) :=
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms);
private static procedure z_TextureParameterIuiv_ovr_2(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIuiv_ovr_2(texture, pname, ¶ms);
private static procedure z_TextureParameteriv_ovr_0(texture: UInt32; pname: TextureParameterName; var param: Int32);
external 'opengl32.dll' name 'glTextureParameteriv';
private static procedure z_TextureParameteriv_ovr_0_anh0001(texture: UInt32; pname: TextureParameterName; param: IntPtr);
external 'opengl32.dll' name 'glTextureParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_TextureParameteriv_ovr_0(texture, pname, param[0]) else
z_TextureParameteriv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; var param: Int32) :=
z_TextureParameteriv_ovr_0(texture, pname, param);
private static procedure z_TextureParameteriv_ovr_2(texture: UInt32; pname: TextureParameterName; param: IntPtr);
external 'opengl32.dll' name 'glTextureParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; param: IntPtr) :=
z_TextureParameteriv_ovr_2(texture, pname, param);
private static procedure z_GenerateTextureMipmap_ovr_0(texture: TextureName);
external 'opengl32.dll' name 'glGenerateTextureMipmap';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateTextureMipmap(texture: TextureName) :=
z_GenerateTextureMipmap_ovr_0(texture);
private static procedure z_BindTextureUnit_ovr_0(&unit: UInt32; texture: TextureName);
external 'opengl32.dll' name 'glBindTextureUnit';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextureUnit(&unit: UInt32; texture: TextureName) :=
z_BindTextureUnit_ovr_0(&unit, texture);
private static procedure z_GetTextureImage_ovr_0(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr);
external 'opengl32.dll' name 'glGetTextureImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureImage(texture: UInt32; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr) :=
z_GetTextureImage_ovr_0(texture, level, format, &type, bufSize, pixels);
private static procedure z_GetCompressedTextureImage_ovr_0(texture: UInt32; level: Int32; bufSize: Int32; pixels: IntPtr);
external 'opengl32.dll' name 'glGetCompressedTextureImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureImage(texture: UInt32; level: Int32; bufSize: Int32; pixels: IntPtr) :=
z_GetCompressedTextureImage_ovr_0(texture, level, bufSize, pixels);
private static procedure z_GetTextureLevelParameterfv_ovr_0(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTextureLevelParameterfv';
private static procedure z_GetTextureLevelParameterfv_ovr_0_anh00001(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms[0]) else
z_GetTextureLevelParameterfv_ovr_0_anh00001(texture, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameterfv_ovr_2(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameterfv_ovr_2(texture, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameteriv_ovr_0(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureLevelParameteriv';
private static procedure z_GetTextureLevelParameteriv_ovr_0_anh00001(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms[0]) else
z_GetTextureLevelParameteriv_ovr_0_anh00001(texture, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameteriv_ovr_2(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameteriv_ovr_2(texture, level, pname, ¶ms);
private static procedure z_GetTextureParameterfv_ovr_0(texture: UInt32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTextureParameterfv';
private static procedure z_GetTextureParameterfv_ovr_0_anh0001(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterfv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms);
private static procedure z_GetTextureParameterfv_ovr_2(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterfv_ovr_2(texture, pname, ¶ms);
private static procedure z_GetTextureParameterIiv_ovr_0(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureParameterIiv';
private static procedure z_GetTextureParameterIiv_ovr_0_anh0001(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterIiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms);
private static procedure z_GetTextureParameterIiv_ovr_2(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIiv_ovr_2(texture, pname, ¶ms);
private static procedure z_GetTextureParameterIuiv_ovr_0(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetTextureParameterIuiv';
private static procedure z_GetTextureParameterIuiv_ovr_0_anh0001(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameterIuiv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms);
private static procedure z_GetTextureParameterIuiv_ovr_2(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIuiv_ovr_2(texture, pname, ¶ms);
private static procedure z_GetTextureParameteriv_ovr_0(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureParameteriv';
private static procedure z_GetTextureParameteriv_ovr_0_anh0001(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms[0]) else
z_GetTextureParameteriv_ovr_0_anh0001(texture, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms);
private static procedure z_GetTextureParameteriv_ovr_2(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameteriv_ovr_2(texture, pname, ¶ms);
private static procedure z_CreateVertexArrays_ovr_0(n: Int32; var arrays: UInt32);
external 'opengl32.dll' name 'glCreateVertexArrays';
private static procedure z_CreateVertexArrays_ovr_0_anh001(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glCreateVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_CreateVertexArrays_ovr_0(n, arrays[0]) else
z_CreateVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; var arrays: UInt32) :=
z_CreateVertexArrays_ovr_0(n, arrays);
private static procedure z_CreateVertexArrays_ovr_2(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glCreateVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: IntPtr) :=
z_CreateVertexArrays_ovr_2(n, arrays);
private static procedure z_DisableVertexArrayAttrib_ovr_0(vaobj: VertexArrayName; index: UInt32);
external 'opengl32.dll' name 'glDisableVertexArrayAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32) :=
z_DisableVertexArrayAttrib_ovr_0(vaobj, index);
private static procedure z_EnableVertexArrayAttrib_ovr_0(vaobj: VertexArrayName; index: UInt32);
external 'opengl32.dll' name 'glEnableVertexArrayAttrib';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32) :=
z_EnableVertexArrayAttrib_ovr_0(vaobj, index);
private static procedure z_VertexArrayElementBuffer_ovr_0(vaobj: VertexArrayName; buffer: BufferName);
external 'opengl32.dll' name 'glVertexArrayElementBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayElementBuffer(vaobj: VertexArrayName; buffer: BufferName) :=
z_VertexArrayElementBuffer_ovr_0(vaobj, buffer);
private static procedure z_VertexArrayVertexBuffer_ovr_0(vaobj: VertexArrayName; bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffer(vaobj: VertexArrayName; bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32) :=
z_VertexArrayVertexBuffer_ovr_0(vaobj, bindingindex, buffer, offset, stride);
private static procedure z_VertexArrayVertexBuffers_ovr_0(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000110(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000101(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000011(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_0_anh0000111(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000011(vaobj, first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000101(vaobj, first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000111(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static procedure z_VertexArrayVertexBuffers_ovr_1_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_1_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_1_anh0000110(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_2(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_2_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_2_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_2_anh0000110(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000010(vaobj, first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2_anh0000100(vaobj, first, count, IntPtr.Zero, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000110(vaobj, first, count, IntPtr.Zero, IntPtr.Zero, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_3_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_3_anh0000101(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000101(vaobj, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_VertexArrayVertexBuffers_ovr_4_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_5_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_6(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_6_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_6_anh0000001(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_6_anh0000101(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000001(vaobj, first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000101(vaobj, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_VertexArrayVertexBuffers_ovr_7_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_6_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_8(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_8_anh0000100(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers[0], offsets, strides) else
z_VertexArrayVertexBuffers_ovr_8_anh0000100(vaobj, first, count, IntPtr.Zero, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_9_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_9_anh0000011(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000011(vaobj, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_VertexArrayVertexBuffers_ovr_10_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_0_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_11_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_2_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_0_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_6_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_18(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_18_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_18_anh0000001(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_18_anh0000011(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000001(vaobj, first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000011(vaobj, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_VertexArrayVertexBuffers_ovr_19_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_18_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_20(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_20_anh0000010(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets[0], strides) else
z_VertexArrayVertexBuffers_ovr_20_anh0000010(vaobj, first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_18_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_24(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
private static procedure z_VertexArrayVertexBuffers_ovr_24_anh0000001(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides[0]) else
z_VertexArrayVertexBuffers_ovr_24_anh0000001(vaobj, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32) :=
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides);
private static procedure z_VertexArrayVertexBuffers_ovr_26(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr) :=
z_VertexArrayVertexBuffers_ovr_26(vaobj, first, count, buffers, offsets, strides);
private static procedure z_VertexArrayAttribBinding_ovr_0(vaobj: VertexArrayName; attribindex: UInt32; bindingindex: UInt32);
external 'opengl32.dll' name 'glVertexArrayAttribBinding';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribBinding(vaobj: VertexArrayName; attribindex: UInt32; bindingindex: UInt32) :=
z_VertexArrayAttribBinding_ovr_0(vaobj, attribindex, bindingindex);
private static procedure z_VertexArrayAttribFormat_ovr_0(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayAttribFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32) :=
z_VertexArrayAttribFormat_ovr_0(vaobj, attribindex, size, &type, normalized, relativeoffset);
private static procedure z_VertexArrayAttribIFormat_ovr_0(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayAttribIFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribIFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32) :=
z_VertexArrayAttribIFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
private static procedure z_VertexArrayAttribLFormat_ovr_0(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayAttribLFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayAttribLFormat(vaobj: VertexArrayName; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32) :=
z_VertexArrayAttribLFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
private static procedure z_VertexArrayBindingDivisor_ovr_0(vaobj: VertexArrayName; bindingindex: UInt32; divisor: UInt32);
external 'opengl32.dll' name 'glVertexArrayBindingDivisor';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayBindingDivisor(vaobj: VertexArrayName; bindingindex: UInt32; divisor: UInt32) :=
z_VertexArrayBindingDivisor_ovr_0(vaobj, bindingindex, divisor);
private static procedure z_GetVertexArrayiv_ovr_0(vaobj: UInt32; pname: VertexArrayPName; var param: Int32);
external 'opengl32.dll' name 'glGetVertexArrayiv';
private static procedure z_GetVertexArrayiv_ovr_0_anh0001(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayiv_ovr_0(vaobj, pname, param[0]) else
z_GetVertexArrayiv_ovr_0_anh0001(vaobj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayiv_ovr_0(vaobj, pname, param);
private static procedure z_GetVertexArrayiv_ovr_2(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayiv_ovr_2(vaobj, pname, param);
private static procedure z_GetVertexArrayIndexediv_ovr_0(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32);
external 'opengl32.dll' name 'glGetVertexArrayIndexediv';
private static procedure z_GetVertexArrayIndexediv_ovr_0_anh00001(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIndexediv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayIndexediv_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param);
private static procedure z_GetVertexArrayIndexediv_ovr_2(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIndexediv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIndexediv_ovr_2(vaobj, index, pname, param);
private static procedure z_GetVertexArrayIndexed64iv_ovr_0(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64);
external 'opengl32.dll' name 'glGetVertexArrayIndexed64iv';
private static procedure z_GetVertexArrayIndexed64iv_ovr_0_anh00001(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIndexed64iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int64) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayIndexed64iv_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64) :=
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param);
private static procedure z_GetVertexArrayIndexed64iv_ovr_2(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIndexed64iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIndexed64iv_ovr_2(vaobj, index, pname, param);
private static procedure z_CreateSamplers_ovr_0(n: Int32; var samplers: UInt32);
external 'opengl32.dll' name 'glCreateSamplers';
private static procedure z_CreateSamplers_ovr_0_anh001(n: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glCreateSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_CreateSamplers_ovr_0(n, samplers[0]) else
z_CreateSamplers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; var samplers: UInt32) :=
z_CreateSamplers_ovr_0(n, samplers);
private static procedure z_CreateSamplers_ovr_2(n: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glCreateSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: IntPtr) :=
z_CreateSamplers_ovr_2(n, samplers);
private static procedure z_CreateProgramPipelines_ovr_0(n: Int32; var pipelines: UInt32);
external 'opengl32.dll' name 'glCreateProgramPipelines';
private static procedure z_CreateProgramPipelines_ovr_0_anh001(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glCreateProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_CreateProgramPipelines_ovr_0(n, pipelines[0]) else
z_CreateProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_CreateProgramPipelines_ovr_0(n, pipelines);
private static procedure z_CreateProgramPipelines_ovr_2(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glCreateProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_CreateProgramPipelines_ovr_2(n, pipelines);
private static procedure z_CreateQueries_ovr_0(target: QueryTarget; n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glCreateQueries';
private static procedure z_CreateQueries_ovr_0_anh0001(target: QueryTarget; n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glCreateQueries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_CreateQueries_ovr_0(target, n, ids[0]) else
z_CreateQueries_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; var ids: UInt32) :=
z_CreateQueries_ovr_0(target, n, ids);
private static procedure z_CreateQueries_ovr_2(target: QueryTarget; n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glCreateQueries';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; ids: IntPtr) :=
z_CreateQueries_ovr_2(target, n, ids);
private static procedure z_GetQueryBufferObjecti64v_ovr_0(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr);
external 'opengl32.dll' name 'glGetQueryBufferObjecti64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjecti64v(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjecti64v_ovr_0(id, buffer, pname, offset);
private static procedure z_GetQueryBufferObjectiv_ovr_0(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr);
external 'opengl32.dll' name 'glGetQueryBufferObjectiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectiv(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectiv_ovr_0(id, buffer, pname, offset);
private static procedure z_GetQueryBufferObjectui64v_ovr_0(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr);
external 'opengl32.dll' name 'glGetQueryBufferObjectui64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectui64v(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectui64v_ovr_0(id, buffer, pname, offset);
private static procedure z_GetQueryBufferObjectuiv_ovr_0(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr);
external 'opengl32.dll' name 'glGetQueryBufferObjectuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryBufferObjectuiv(id: QueryName; buffer: BufferName; pname: QueryObjectParameterName; offset: IntPtr) :=
z_GetQueryBufferObjectuiv_ovr_0(id, buffer, pname, offset);
end;
[PCUNotRestore]
glDrawBuffersARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawBuffersARB_ovr_0(n: Int32; var bufs: DrawBufferMode);
external 'opengl32.dll' name 'glDrawBuffersARB';
private static procedure z_DrawBuffersARB_ovr_0_anh001(n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glDrawBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; bufs: array of DrawBufferMode) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_DrawBuffersARB_ovr_0(n, bufs[0]) else
z_DrawBuffersARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; var bufs: DrawBufferMode) :=
z_DrawBuffersARB_ovr_0(n, bufs);
private static procedure z_DrawBuffersARB_ovr_2(n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glDrawBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; bufs: IntPtr) :=
z_DrawBuffersARB_ovr_2(n, bufs);
end;
[PCUNotRestore]
glDrawBuffersBlendARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendEquationiARB_ovr_0(buf: UInt32; mode: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationiARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationiARB(buf: UInt32; mode: BlendEquationModeEXT) :=
z_BlendEquationiARB_ovr_0(buf, mode);
private static procedure z_BlendEquationSeparateiARB_ovr_0(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationSeparateiARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateiARB(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT) :=
z_BlendEquationSeparateiARB_ovr_0(buf, modeRGB, modeAlpha);
private static procedure z_BlendFunciARB_ovr_0(buf: UInt32; src: BlendingFactor; dst: BlendingFactor);
external 'opengl32.dll' name 'glBlendFunciARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFunciARB(buf: UInt32; src: BlendingFactor; dst: BlendingFactor) :=
z_BlendFunciARB_ovr_0(buf, src, dst);
private static procedure z_BlendFuncSeparateiARB_ovr_0(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor);
external 'opengl32.dll' name 'glBlendFuncSeparateiARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateiARB(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor) :=
z_BlendFuncSeparateiARB_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
end;
[PCUNotRestore]
glDrawElementsBaseVertexARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawElementsBaseVertex_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32);
external 'opengl32.dll' name 'glDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsBaseVertex(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32) :=
z_DrawElementsBaseVertex_ovr_0(mode, count, &type, indices, basevertex);
private static procedure z_DrawRangeElementsBaseVertex_ovr_0(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32);
external 'opengl32.dll' name 'glDrawRangeElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementsBaseVertex(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr; basevertex: Int32) :=
z_DrawRangeElementsBaseVertex_ovr_0(mode, start, &end, count, &type, indices, basevertex);
private static procedure z_DrawElementsInstancedBaseVertex_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32);
external 'opengl32.dll' name 'glDrawElementsInstancedBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedBaseVertex(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; instancecount: Int32; basevertex: Int32) :=
z_DrawElementsInstancedBaseVertex_ovr_0(mode, count, &type, indices, instancecount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_0(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0010100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0010001(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0000101(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_0_anh0010101(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count[0], &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000101(mode, count[0], &type, IntPtr.Zero, drawcount, IntPtr.Zero) else
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010001(mode, IntPtr.Zero, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010101(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private static procedure z_MultiDrawElementsBaseVertex_ovr_1_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_1_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_1_anh0010100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_2(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_2_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_2_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_2_anh0010100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0000100(mode, count[0], &type, IntPtr.Zero, drawcount, basevertex) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2_anh0010000(mode, IntPtr.Zero, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_3_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_3_anh0010001(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count[0], &type, indices, drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010001(mode, IntPtr.Zero, &type, indices, drawcount, IntPtr.Zero);
private static procedure z_MultiDrawElementsBaseVertex_ovr_4_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_5_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_6(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_6_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_6_anh0000001(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_6_anh0010001(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (count<>nil) and (count.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0000001(mode, count[0], &type, indices, drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0010001(mode, IntPtr.Zero, &type, indices, drawcount, IntPtr.Zero);
private static procedure z_MultiDrawElementsBaseVertex_ovr_7_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_8(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_8_anh0010000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_8(mode, count[0], &type, indices, drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_8_anh0010000(mode, IntPtr.Zero, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_9_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_9_anh0000101(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000101(mode, count, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private static procedure z_MultiDrawElementsBaseVertex_ovr_10_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_11_anh0000100(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_2_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_0_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_6_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_8(mode, count, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_18(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_18_anh0000100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_18_anh0000001(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_18_anh0000101(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (indices<>nil) and (indices.Length<>0) then
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000001(mode, count, &type, indices[0], drawcount, IntPtr.Zero) else
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000101(mode, count, &type, IntPtr.Zero, drawcount, IntPtr.Zero);
private static procedure z_MultiDrawElementsBaseVertex_ovr_19_anh0000100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_20(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_20_anh0000100(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices[0], drawcount, basevertex) else
z_MultiDrawElementsBaseVertex_ovr_20_anh0000100(mode, count, &type, IntPtr.Zero, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_18_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_24(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
private static procedure z_MultiDrawElementsBaseVertex_ovr_24_anh0000001(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32) :=
if (basevertex<>nil) and (basevertex.Length<>0) then
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex[0]) else
z_MultiDrawElementsBaseVertex_ovr_24_anh0000001(mode, count, &type, indices, drawcount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32) :=
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex);
private static procedure z_MultiDrawElementsBaseVertex_ovr_26(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
external 'opengl32.dll' name 'glMultiDrawElementsBaseVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr) :=
z_MultiDrawElementsBaseVertex_ovr_26(mode, count, &type, indices, drawcount, basevertex);
end;
[PCUNotRestore]
glDrawIndirectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawArraysIndirect_ovr_0(mode: PrimitiveType; indirect: IntPtr);
external 'opengl32.dll' name 'glDrawArraysIndirect';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysIndirect(mode: PrimitiveType; indirect: IntPtr) :=
z_DrawArraysIndirect_ovr_0(mode, indirect);
private static procedure z_DrawElementsIndirect_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr);
external 'opengl32.dll' name 'glDrawElementsIndirect';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsIndirect(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr) :=
z_DrawElementsIndirect_ovr_0(mode, &type, indirect);
end;
[PCUNotRestore]
glDrawInstancedARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawArraysInstancedARB_ovr_0(mode: PrimitiveType; first: Int32; count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glDrawArraysInstancedARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedARB(mode: PrimitiveType; first: Int32; count: Int32; primcount: Int32) :=
z_DrawArraysInstancedARB_ovr_0(mode, first, count, primcount);
private static procedure z_DrawElementsInstancedARB_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glDrawElementsInstancedARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedARB(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32) :=
z_DrawElementsInstancedARB_ovr_0(mode, count, &type, indices, primcount);
end;
[PCUNotRestore]
glFragmentProgramARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramStringARB_ovr_0(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
external 'opengl32.dll' name 'glProgramStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramStringARB(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr) :=
z_ProgramStringARB_ovr_0(target, format, len, string);
private static procedure z_BindProgramARB_ovr_0(target: ProgramTarget; &program: UInt32);
external 'opengl32.dll' name 'glBindProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramARB(target: ProgramTarget; &program: UInt32) :=
z_BindProgramARB_ovr_0(target, &program);
private static procedure z_DeleteProgramsARB_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glDeleteProgramsARB';
private static procedure z_DeleteProgramsARB_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_DeleteProgramsARB_ovr_0(n, programs[0]) else
z_DeleteProgramsARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; var programs: UInt32) :=
z_DeleteProgramsARB_ovr_0(n, programs);
private static procedure z_DeleteProgramsARB_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: IntPtr) :=
z_DeleteProgramsARB_ovr_2(n, programs);
private static procedure z_GenProgramsARB_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glGenProgramsARB';
private static procedure z_GenProgramsARB_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_GenProgramsARB_ovr_0(n, programs[0]) else
z_GenProgramsARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; var programs: UInt32) :=
z_GenProgramsARB_ovr_0(n, programs);
private static procedure z_GenProgramsARB_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: IntPtr) :=
z_GenProgramsARB_ovr_2(n, programs);
private static procedure z_ProgramEnvParameter4dARB_ovr_0(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramEnvParameter4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real) :=
z_ProgramEnvParameter4dARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameter4dvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
private static procedure z_ProgramEnvParameter4dvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameter4dvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4dvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameter4dvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4fARB_ovr_0(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramEnvParameter4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single) :=
z_ProgramEnvParameter4fARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameter4fvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
private static procedure z_ProgramEnvParameter4fvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameter4fvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4fvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameter4fvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4dARB_ovr_0(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramLocalParameter4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real) :=
z_ProgramLocalParameter4dARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameter4dvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
private static procedure z_ProgramLocalParameter4dvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameter4dvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4dvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameter4dvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4fARB_ovr_0(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramLocalParameter4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single) :=
z_ProgramLocalParameter4fARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameter4fvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
private static procedure z_ProgramLocalParameter4fvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameter4fvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4fvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameter4fvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterdvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
private static procedure z_GetProgramEnvParameterdvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterdvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterdvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterdvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterfvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
private static procedure z_GetProgramEnvParameterfvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterfvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterfvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterfvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterdvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
private static procedure z_GetProgramLocalParameterdvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterdvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterdvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterdvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterfvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
private static procedure z_GetProgramLocalParameterfvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterfvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterfvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterfvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramivARB_ovr_0(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramivARB';
private static procedure z_GetProgramivARB_ovr_0_anh0001(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramivARB_ovr_0(target, pname, ¶ms[0]) else
z_GetProgramivARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32) :=
z_GetProgramivARB_ovr_0(target, pname, ¶ms);
private static procedure z_GetProgramivARB_ovr_2(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr) :=
z_GetProgramivARB_ovr_2(target, pname, ¶ms);
private static procedure z_GetProgramStringARB_ovr_0(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
external 'opengl32.dll' name 'glGetProgramStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringARB(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr) :=
z_GetProgramStringARB_ovr_0(target, pname, string);
private static function z_IsProgramARB_ovr_0(&program: UInt32): boolean;
external 'opengl32.dll' name 'glIsProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramARB(&program: UInt32): boolean :=
z_IsProgramARB_ovr_0(&program);
end;
[PCUNotRestore]
glFramebufferNoAttachmentsARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferParameteri_ovr_0(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32);
external 'opengl32.dll' name 'glFramebufferParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferParameteri(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32) :=
z_FramebufferParameteri_ovr_0(target, pname, param);
private static procedure z_GetFramebufferParameteriv_ovr_0(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFramebufferParameteriv';
private static procedure z_GetFramebufferParameteriv_ovr_0_anh0001(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetFramebufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetFramebufferParameteriv_ovr_2(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferParameteriv_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glFramebufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_IsRenderbuffer_ovr_0(renderbuffer: RenderbufferName): boolean;
external 'opengl32.dll' name 'glIsRenderbuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsRenderbuffer(renderbuffer: RenderbufferName): boolean :=
z_IsRenderbuffer_ovr_0(renderbuffer);
private static procedure z_BindRenderbuffer_ovr_0(target: RenderbufferTarget; renderbuffer: RenderbufferName);
external 'opengl32.dll' name 'glBindRenderbuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindRenderbuffer(target: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_BindRenderbuffer_ovr_0(target, renderbuffer);
private static procedure z_DeleteRenderbuffers_ovr_0(n: Int32; var renderbuffers: UInt32);
external 'opengl32.dll' name 'glDeleteRenderbuffers';
private static procedure z_DeleteRenderbuffers_ovr_0_anh001(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_DeleteRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_DeleteRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_DeleteRenderbuffers_ovr_0(n, renderbuffers);
private static procedure z_DeleteRenderbuffers_ovr_2(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_DeleteRenderbuffers_ovr_2(n, renderbuffers);
private static procedure z_GenRenderbuffers_ovr_0(n: Int32; var renderbuffers: UInt32);
external 'opengl32.dll' name 'glGenRenderbuffers';
private static procedure z_GenRenderbuffers_ovr_0_anh001(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glGenRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_GenRenderbuffers_ovr_0(n, renderbuffers[0]) else
z_GenRenderbuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; var renderbuffers: UInt32) :=
z_GenRenderbuffers_ovr_0(n, renderbuffers);
private static procedure z_GenRenderbuffers_ovr_2(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glGenRenderbuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: IntPtr) :=
z_GenRenderbuffers_ovr_2(n, renderbuffers);
private static procedure z_RenderbufferStorage_ovr_0(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorage(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorage_ovr_0(target, _internalformat, width, height);
private static procedure z_GetRenderbufferParameteriv_ovr_0(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetRenderbufferParameteriv';
private static procedure z_GetRenderbufferParameteriv_ovr_0_anh0001(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetRenderbufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetRenderbufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetRenderbufferParameteriv_ovr_2(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetRenderbufferParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetRenderbufferParameteriv_ovr_2(target, pname, ¶ms);
private static function z_IsFramebuffer_ovr_0(framebuffer: FramebufferName): boolean;
external 'opengl32.dll' name 'glIsFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFramebuffer(framebuffer: FramebufferName): boolean :=
z_IsFramebuffer_ovr_0(framebuffer);
private static procedure z_BindFramebuffer_ovr_0(target: FramebufferTarget; framebuffer: FramebufferName);
external 'opengl32.dll' name 'glBindFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFramebuffer(target: FramebufferTarget; framebuffer: FramebufferName) :=
z_BindFramebuffer_ovr_0(target, framebuffer);
private static procedure z_DeleteFramebuffers_ovr_0(n: Int32; var framebuffers: UInt32);
external 'opengl32.dll' name 'glDeleteFramebuffers';
private static procedure z_DeleteFramebuffers_ovr_0_anh001(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_DeleteFramebuffers_ovr_0(n, framebuffers[0]) else
z_DeleteFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_DeleteFramebuffers_ovr_0(n, framebuffers);
private static procedure z_DeleteFramebuffers_ovr_2(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_DeleteFramebuffers_ovr_2(n, framebuffers);
private static procedure z_GenFramebuffers_ovr_0(n: Int32; var framebuffers: UInt32);
external 'opengl32.dll' name 'glGenFramebuffers';
private static procedure z_GenFramebuffers_ovr_0_anh001(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glGenFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_GenFramebuffers_ovr_0(n, framebuffers[0]) else
z_GenFramebuffers_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; var framebuffers: UInt32) :=
z_GenFramebuffers_ovr_0(n, framebuffers);
private static procedure z_GenFramebuffers_ovr_2(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glGenFramebuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: IntPtr) :=
z_GenFramebuffers_ovr_2(n, framebuffers);
private static function z_CheckFramebufferStatus_ovr_0(target: FramebufferTarget): FramebufferStatus;
external 'opengl32.dll' name 'glCheckFramebufferStatus';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckFramebufferStatus(target: FramebufferTarget): FramebufferStatus :=
z_CheckFramebufferStatus_ovr_0(target);
private static procedure z_FramebufferTexture1D_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTexture1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture1D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture1D_ovr_0(target, attachment, textarget, texture, level);
private static procedure z_FramebufferTexture2D_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTexture2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture2D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture2D_ovr_0(target, attachment, textarget, texture, level);
private static procedure z_FramebufferTexture3D_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32);
external 'opengl32.dll' name 'glFramebufferTexture3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture3D(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32) :=
z_FramebufferTexture3D_ovr_0(target, attachment, textarget, texture, level, zoffset);
private static procedure z_FramebufferRenderbuffer_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName);
external 'opengl32.dll' name 'glFramebufferRenderbuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferRenderbuffer(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: RenderbufferName) :=
z_FramebufferRenderbuffer_ovr_0(target, attachment, _renderbuffertarget, renderbuffer);
private static procedure z_GetFramebufferAttachmentParameteriv_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameteriv';
private static procedure z_GetFramebufferAttachmentParameteriv_ovr_0_anh00001(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms[0]) else
z_GetFramebufferAttachmentParameteriv_ovr_0_anh00001(target, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms);
private static procedure z_GetFramebufferAttachmentParameteriv_ovr_2(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferAttachmentParameteriv_ovr_2(target, attachment, pname, ¶ms);
private static procedure z_GenerateMipmap_ovr_0(target: TextureTarget);
external 'opengl32.dll' name 'glGenerateMipmap';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMipmap(target: TextureTarget) :=
z_GenerateMipmap_ovr_0(target);
private static procedure z_BlitFramebuffer_ovr_0(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter);
external 'opengl32.dll' name 'glBlitFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlitFramebuffer(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter) :=
z_BlitFramebuffer_ovr_0(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
private static procedure z_RenderbufferStorageMultisample_ovr_0(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorageMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisample(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageMultisample_ovr_0(target, samples, _internalformat, width, height);
private static procedure z_FramebufferTextureLayer_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glFramebufferTextureLayer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayer(target: FramebufferTarget; attachment: FramebufferAttachment; texture: TextureName; level: Int32; layer: Int32) :=
z_FramebufferTextureLayer_ovr_0(target, attachment, texture, level, layer);
end;
[PCUNotRestore]
glGeometryShader4ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramParameteriARB_ovr_0(&program: UInt32; pname: ProgramParameterPName; value: Int32);
external 'opengl32.dll' name 'glProgramParameteriARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteriARB(&program: UInt32; pname: ProgramParameterPName; value: Int32) :=
z_ProgramParameteriARB_ovr_0(&program, pname, value);
private static procedure z_FramebufferTextureARB_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTextureARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32) :=
z_FramebufferTextureARB_ovr_0(target, attachment, texture, level);
private static procedure z_FramebufferTextureLayerARB_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glFramebufferTextureLayerARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayerARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32) :=
z_FramebufferTextureLayerARB_ovr_0(target, attachment, texture, level, layer);
private static procedure z_FramebufferTextureFaceARB_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget);
external 'opengl32.dll' name 'glFramebufferTextureFaceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureFaceARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget) :=
z_FramebufferTextureFaceARB_ovr_0(target, attachment, texture, level, face);
end;
[PCUNotRestore]
glGetProgramBinaryARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetProgramBinary_ovr_0(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
private static procedure z_GetProgramBinary_ovr_0_anh000100(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
private static procedure z_GetProgramBinary_ovr_0_anh000010(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
private static procedure z_GetProgramBinary_ovr_0_anh000110(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000010(&program, bufSize, length[0], IntPtr.Zero, binary) else
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000110(&program, bufSize, IntPtr.Zero, IntPtr.Zero, binary);
private static procedure z_GetProgramBinary_ovr_1_anh000100(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; var binaryFormat: DummyEnum; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat, binary) else
z_GetProgramBinary_ovr_0_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat, binary);
private static procedure z_GetProgramBinary_ovr_2(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
private static procedure z_GetProgramBinary_ovr_2_anh000100(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; binaryFormat: IntPtr; binary: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramBinary_ovr_2(&program, bufSize, length[0], binaryFormat, binary) else
z_GetProgramBinary_ovr_2_anh000100(&program, bufSize, IntPtr.Zero, binaryFormat, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_0_anh000010(&program, bufSize, length, IntPtr.Zero, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; binary: IntPtr) :=
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr) :=
z_GetProgramBinary_ovr_2(&program, bufSize, length, binaryFormat, binary);
private static procedure z_GetProgramBinary_ovr_6(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
private static procedure z_GetProgramBinary_ovr_6_anh000010(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: array of DummyEnum; binary: IntPtr) :=
if (binaryFormat<>nil) and (binaryFormat.Length<>0) then
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat[0], binary) else
z_GetProgramBinary_ovr_6_anh000010(&program, bufSize, length, IntPtr.Zero, binary);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr) :=
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat, binary);
private static procedure z_GetProgramBinary_ovr_8(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr);
external 'opengl32.dll' name 'glGetProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; binaryFormat: IntPtr; binary: IntPtr) :=
z_GetProgramBinary_ovr_8(&program, bufSize, length, binaryFormat, binary);
private static procedure z_ProgramBinary_ovr_0(&program: UInt32; binaryFormat: DummyEnum; binary: IntPtr; length: Int32);
external 'opengl32.dll' name 'glProgramBinary';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBinary(&program: UInt32; binaryFormat: DummyEnum; binary: IntPtr; length: Int32) :=
z_ProgramBinary_ovr_0(&program, binaryFormat, binary, length);
private static procedure z_ProgramParameteri_ovr_0(&program: ProgramName; pname: ProgramParameterPName; value: Int32);
external 'opengl32.dll' name 'glProgramParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteri(&program: ProgramName; pname: ProgramParameterPName; value: Int32) :=
z_ProgramParameteri_ovr_0(&program, pname, value);
end;
[PCUNotRestore]
glGetTextureSubImageARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetTextureSubImage_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr);
external 'opengl32.dll' name 'glGetTextureSubImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; pixels: IntPtr) :=
z_GetTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, bufSize, pixels);
private static procedure z_GetCompressedTextureSubImage_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; bufSize: Int32; pixels: IntPtr);
external 'opengl32.dll' name 'glGetCompressedTextureSubImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureSubImage(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; bufSize: Int32; pixels: IntPtr) :=
z_GetCompressedTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
end;
[PCUNotRestore]
glGlSpirvARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SpecializeShaderARB_ovr_0(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32);
external 'opengl32.dll' name 'glSpecializeShaderARB';
private static procedure z_SpecializeShaderARB_ovr_0_anh000010(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
external 'opengl32.dll' name 'glSpecializeShaderARB';
private static procedure z_SpecializeShaderARB_ovr_0_anh000001(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
private static procedure z_SpecializeShaderARB_ovr_0_anh000011(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], IntPtr.Zero) else
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000011(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_SpecializeShaderARB_ovr_1_anh000010(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
external 'opengl32.dll' name 'glSpecializeShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShaderARB_ovr_0_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_SpecializeShaderARB_ovr_2(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
private static procedure z_SpecializeShaderARB_ovr_2_anh000010(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShaderARB_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShaderARB_ovr_2_anh000010(shader, par_2_str_ptr, numSpecializationConstants, IntPtr.Zero, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShaderARB_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_SpecializeShaderARB_ovr_6(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
external 'opengl32.dll' name 'glSpecializeShaderARB';
private static procedure z_SpecializeShaderARB_ovr_6_anh000001(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_6_anh000001(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShaderARB_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_SpecializeShaderARB_ovr_8(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
external 'opengl32.dll' name 'glSpecializeShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: string; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShaderARB_ovr_8(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: array of UInt32) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], IntPtr.Zero) else
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000011(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShaderARB_ovr_0_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr) :=
if (pConstantIndex<>nil) and (pConstantIndex.Length<>0) then
z_SpecializeShaderARB_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue) else
z_SpecializeShaderARB_ovr_2_anh000010(shader, pEntryPoint, numSpecializationConstants, IntPtr.Zero, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32) :=
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_0_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32) :=
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr) :=
z_SpecializeShaderARB_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32) :=
if (pConstantValue<>nil) and (pConstantValue.Length<>0) then
z_SpecializeShaderARB_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]) else
z_SpecializeShaderARB_ovr_6_anh000001(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32) :=
z_SpecializeShaderARB_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr) :=
z_SpecializeShaderARB_ovr_8(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
[PCUNotRestore]
glGpuShaderFp64ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Uniform1d_ovr_0(location: Int32; x: real);
external 'opengl32.dll' name 'glUniform1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1d(location: Int32; x: real) :=
z_Uniform1d_ovr_0(location, x);
private static procedure z_Uniform2d_ovr_0(location: Int32; x: real; y: real);
external 'opengl32.dll' name 'glUniform2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2d(location: Int32; x: real; y: real) :=
z_Uniform2d_ovr_0(location, x, y);
private static procedure z_Uniform3d_ovr_0(location: Int32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glUniform3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3d(location: Int32; x: real; y: real; z: real) :=
z_Uniform3d_ovr_0(location, x, y, z);
private static procedure z_Uniform4d_ovr_0(location: Int32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glUniform4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4d(location: Int32; x: real; y: real; z: real; w: real) :=
z_Uniform4d_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1dv_ovr_0(location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glUniform1dv';
private static procedure z_Uniform1dv_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1dv_ovr_0(location, count, value[0]) else
z_Uniform1dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: real) :=
z_Uniform1dv_ovr_0(location, count, value);
private static procedure z_Uniform1dv_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1dv_ovr_2(location, count, value);
private static procedure z_Uniform2dv_ovr_0(location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glUniform2dv';
private static procedure z_Uniform2dv_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2dv_ovr_0(location, count, value[0]) else
z_Uniform2dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: real) :=
z_Uniform2dv_ovr_0(location, count, value);
private static procedure z_Uniform2dv_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2dv_ovr_2(location, count, value);
private static procedure z_Uniform3dv_ovr_0(location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glUniform3dv';
private static procedure z_Uniform3dv_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3dv_ovr_0(location, count, value[0]) else
z_Uniform3dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: real) :=
z_Uniform3dv_ovr_0(location, count, value);
private static procedure z_Uniform3dv_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3dv_ovr_2(location, count, value);
private static procedure z_Uniform4dv_ovr_0(location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glUniform4dv';
private static procedure z_Uniform4dv_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4dv_ovr_0(location, count, value[0]) else
z_Uniform4dv_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: real) :=
z_Uniform4dv_ovr_0(location, count, value);
private static procedure z_Uniform4dv_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4dv_ovr_2(location, count, value);
private static procedure z_UniformMatrix2dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix2dv';
private static procedure z_UniformMatrix2dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix2dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix3dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix3dv';
private static procedure z_UniformMatrix3dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix3dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix4dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix4dv';
private static procedure z_UniformMatrix4dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix4dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix2x3dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix2x3dv';
private static procedure z_UniformMatrix2x3dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix2x3dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x3dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix2x4dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix2x4dv';
private static procedure z_UniformMatrix2x4dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2x4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix2x4dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2x4dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix3x2dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix3x2dv';
private static procedure z_UniformMatrix3x2dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix3x2dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x2dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix3x4dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix3x4dv';
private static procedure z_UniformMatrix3x4dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3x4dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix3x4dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3x4dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix4x2dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix4x2dv';
private static procedure z_UniformMatrix4x2dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x2dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix4x2dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x2dv_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix4x3dv_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glUniformMatrix4x3dv';
private static procedure z_UniformMatrix4x3dv_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4x3dv_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix4x3dv_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4x3dv_ovr_2(location, count, transpose, value);
private static procedure z_GetUniformdv_ovr_0(&program: ProgramName; location: Int32; var ¶ms: real);
external 'opengl32.dll' name 'glGetUniformdv';
private static procedure z_GetUniformdv_ovr_0_anh0001(&program: ProgramName; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformdv_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformdv_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; var ¶ms: real) :=
z_GetUniformdv_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformdv_ovr_2(&program: ProgramName; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; ¶ms: IntPtr) :=
z_GetUniformdv_ovr_2(&program, location, ¶ms);
end;
[PCUNotRestore]
glGpuShaderInt64ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Uniform1i64ARB_ovr_0(location: Int32; x: Int64);
external 'opengl32.dll' name 'glUniform1i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64ARB(location: Int32; x: Int64) :=
z_Uniform1i64ARB_ovr_0(location, x);
private static procedure z_Uniform2i64ARB_ovr_0(location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glUniform2i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64ARB(location: Int32; x: Int64; y: Int64) :=
z_Uniform2i64ARB_ovr_0(location, x, y);
private static procedure z_Uniform3i64ARB_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glUniform3i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64ARB(location: Int32; x: Int64; y: Int64; z: Int64) :=
z_Uniform3i64ARB_ovr_0(location, x, y, z);
private static procedure z_Uniform4i64ARB_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glUniform4i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64ARB(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_Uniform4i64ARB_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1i64vARB_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform1i64vARB';
private static procedure z_Uniform1i64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1i64vARB_ovr_0(location, count, value[0]) else
z_Uniform1i64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; var value: Int64) :=
z_Uniform1i64vARB_ovr_0(location, count, value);
private static procedure z_Uniform1i64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1i64vARB_ovr_2(location, count, value);
private static procedure z_Uniform2i64vARB_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform2i64vARB';
private static procedure z_Uniform2i64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2i64vARB_ovr_0(location, count, value[0]) else
z_Uniform2i64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; var value: Int64) :=
z_Uniform2i64vARB_ovr_0(location, count, value);
private static procedure z_Uniform2i64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2i64vARB_ovr_2(location, count, value);
private static procedure z_Uniform3i64vARB_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform3i64vARB';
private static procedure z_Uniform3i64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3i64vARB_ovr_0(location, count, value[0]) else
z_Uniform3i64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; var value: Int64) :=
z_Uniform3i64vARB_ovr_0(location, count, value);
private static procedure z_Uniform3i64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3i64vARB_ovr_2(location, count, value);
private static procedure z_Uniform4i64vARB_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform4i64vARB';
private static procedure z_Uniform4i64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4i64vARB_ovr_0(location, count, value[0]) else
z_Uniform4i64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; var value: Int64) :=
z_Uniform4i64vARB_ovr_0(location, count, value);
private static procedure z_Uniform4i64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4i64vARB_ovr_2(location, count, value);
private static procedure z_Uniform1ui64ARB_ovr_0(location: Int32; x: UInt64);
external 'opengl32.dll' name 'glUniform1ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64ARB(location: Int32; x: UInt64) :=
z_Uniform1ui64ARB_ovr_0(location, x);
private static procedure z_Uniform2ui64ARB_ovr_0(location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glUniform2ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64ARB(location: Int32; x: UInt64; y: UInt64) :=
z_Uniform2ui64ARB_ovr_0(location, x, y);
private static procedure z_Uniform3ui64ARB_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glUniform3ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64ARB(location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_Uniform3ui64ARB_ovr_0(location, x, y, z);
private static procedure z_Uniform4ui64ARB_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glUniform4ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64ARB(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_Uniform4ui64ARB_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1ui64vARB_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform1ui64vARB';
private static procedure z_Uniform1ui64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1ui64vARB_ovr_0(location, count, value[0]) else
z_Uniform1ui64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform1ui64vARB_ovr_0(location, count, value);
private static procedure z_Uniform1ui64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1ui64vARB_ovr_2(location, count, value);
private static procedure z_Uniform2ui64vARB_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform2ui64vARB';
private static procedure z_Uniform2ui64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2ui64vARB_ovr_0(location, count, value[0]) else
z_Uniform2ui64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform2ui64vARB_ovr_0(location, count, value);
private static procedure z_Uniform2ui64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2ui64vARB_ovr_2(location, count, value);
private static procedure z_Uniform3ui64vARB_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform3ui64vARB';
private static procedure z_Uniform3ui64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3ui64vARB_ovr_0(location, count, value[0]) else
z_Uniform3ui64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform3ui64vARB_ovr_0(location, count, value);
private static procedure z_Uniform3ui64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3ui64vARB_ovr_2(location, count, value);
private static procedure z_Uniform4ui64vARB_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform4ui64vARB';
private static procedure z_Uniform4ui64vARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4ui64vARB_ovr_0(location, count, value[0]) else
z_Uniform4ui64vARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform4ui64vARB_ovr_0(location, count, value);
private static procedure z_Uniform4ui64vARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4ui64vARB_ovr_2(location, count, value);
private static procedure z_GetUniformi64vARB_ovr_0(&program: UInt32; location: Int32; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetUniformi64vARB';
private static procedure z_GetUniformi64vARB_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformi64vARB_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformi64vARB_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; var ¶ms: Int64) :=
z_GetUniformi64vARB_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformi64vARB_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformi64vARB_ovr_2(&program, location, ¶ms);
private static procedure z_GetUniformui64vARB_ovr_0(&program: UInt32; location: Int32; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetUniformui64vARB';
private static procedure z_GetUniformui64vARB_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformui64vARB_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformui64vARB_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; var ¶ms: UInt64) :=
z_GetUniformui64vARB_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformui64vARB_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformui64vARB_ovr_2(&program, location, ¶ms);
private static procedure z_GetnUniformi64vARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetnUniformi64vARB';
private static procedure z_GetnUniformi64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformi64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformi64vARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformi64vARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int64) :=
z_GetnUniformi64vARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformi64vARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformi64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformi64vARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformui64vARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetnUniformui64vARB';
private static procedure z_GetnUniformui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformui64vARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformui64vARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt64) :=
z_GetnUniformui64vARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformui64vARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformui64vARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_ProgramUniform1i64ARB_ovr_0(&program: UInt32; location: Int32; x: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64ARB(&program: UInt32; location: Int32; x: Int64) :=
z_ProgramUniform1i64ARB_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2i64ARB_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64) :=
z_ProgramUniform2i64ARB_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3i64ARB_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64) :=
z_ProgramUniform3i64ARB_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4i64ARB_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_ProgramUniform4i64ARB_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1i64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64vARB';
private static procedure z_ProgramUniform1i64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1i64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1i64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform1i64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1i64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1i64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2i64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64vARB';
private static procedure z_ProgramUniform2i64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2i64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2i64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform2i64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2i64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2i64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3i64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64vARB';
private static procedure z_ProgramUniform3i64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3i64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3i64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform3i64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3i64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3i64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4i64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64vARB';
private static procedure z_ProgramUniform4i64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4i64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4i64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform4i64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4i64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4i64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1ui64ARB_ovr_0(&program: UInt32; location: Int32; x: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64ARB(&program: UInt32; location: Int32; x: UInt64) :=
z_ProgramUniform1ui64ARB_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2ui64ARB_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64) :=
z_ProgramUniform2ui64ARB_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3ui64ARB_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_ProgramUniform3ui64ARB_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4ui64ARB_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64ARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_ProgramUniform4ui64ARB_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1ui64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64vARB';
private static procedure z_ProgramUniform1ui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1ui64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1ui64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform1ui64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1ui64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1ui64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64vARB';
private static procedure z_ProgramUniform2ui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2ui64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2ui64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform2ui64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2ui64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64vARB';
private static procedure z_ProgramUniform3ui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3ui64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3ui64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform3ui64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3ui64vARB_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vARB_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64vARB';
private static procedure z_ProgramUniform4ui64vARB_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4ui64vARB_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4ui64vARB_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform4ui64vARB_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vARB_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4ui64vARB_ovr_2(&program, location, count, value);
end;
[PCUNotRestore]
glImagingARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendColor_ovr_0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glBlendColor';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColor(red: single; green: single; blue: single; alpha: single) :=
z_BlendColor_ovr_0(red, green, blue, alpha);
private static procedure z_BlendEquation_ovr_0(mode: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquation';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquation(mode: BlendEquationModeEXT) :=
z_BlendEquation_ovr_0(mode);
private static procedure z_ColorTable_ovr_0(target: ColorTableTarget; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr);
external 'opengl32.dll' name 'glColorTable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTable(target: ColorTableTarget; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr) :=
z_ColorTable_ovr_0(target, _internalformat, width, format, &type, table);
private static procedure z_ColorTableParameterfv_ovr_0(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; var ¶ms: single);
external 'opengl32.dll' name 'glColorTableParameterfv';
private static procedure z_ColorTableParameterfv_ovr_0_anh0001(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ColorTableParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_ColorTableParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; var ¶ms: single) :=
z_ColorTableParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_ColorTableParameterfv_ovr_2(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_ColorTableParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_ColorTableParameteriv_ovr_0(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; var ¶ms: Int32);
external 'opengl32.dll' name 'glColorTableParameteriv';
private static procedure z_ColorTableParameteriv_ovr_0_anh0001(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameteriv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ColorTableParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_ColorTableParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameteriv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; var ¶ms: Int32) :=
z_ColorTableParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_ColorTableParameteriv_ovr_2(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameteriv(target: ColorTableTarget; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_ColorTableParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_CopyColorTable_ovr_0(target: ColorTableTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyColorTable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorTable(target: ColorTableTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32) :=
z_CopyColorTable_ovr_0(target, _internalformat, x, y, width);
private static procedure z_GetColorTable_ovr_0(target: ColorTableTarget; format: PixelFormat; &type: PixelType; table: IntPtr);
external 'opengl32.dll' name 'glGetColorTable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTable(target: ColorTableTarget; format: PixelFormat; &type: PixelType; table: IntPtr) :=
z_GetColorTable_ovr_0(target, format, &type, table);
private static procedure z_GetColorTableParameterfv_ovr_0(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single);
external 'opengl32.dll' name 'glGetColorTableParameterfv';
private static procedure z_GetColorTableParameterfv_ovr_0_anh0001(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single) :=
z_GetColorTableParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameterfv_ovr_2(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_GetColorTableParameteriv_ovr_0(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetColorTableParameteriv';
private static procedure z_GetColorTableParameteriv_ovr_0_anh0001(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameteriv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameteriv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32) :=
z_GetColorTableParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameteriv_ovr_2(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameteriv(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_ColorSubTable_ovr_0(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glColorSubTable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorSubTable(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ColorSubTable_ovr_0(target, start, count, format, &type, data);
private static procedure z_CopyColorSubTable_ovr_0(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyColorSubTable';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorSubTable(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyColorSubTable_ovr_0(target, start, x, y, width);
private static procedure z_ConvolutionFilter1D_ovr_0(target: ConvolutionTarget; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glConvolutionFilter1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter1D(target: ConvolutionTarget; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_ConvolutionFilter1D_ovr_0(target, _internalformat, width, format, &type, image);
private static procedure z_ConvolutionFilter2D_ovr_0(target: ConvolutionTarget; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glConvolutionFilter2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter2D(target: ConvolutionTarget; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_ConvolutionFilter2D_ovr_0(target, _internalformat, width, height, format, &type, image);
private static procedure z_ConvolutionParameterf_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: single);
external 'opengl32.dll' name 'glConvolutionParameterf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterf(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: single) :=
z_ConvolutionParameterf_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterfv_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: single);
external 'opengl32.dll' name 'glConvolutionParameterfv';
private static procedure z_ConvolutionParameterfv_ovr_0_anh0001(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ConvolutionParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_ConvolutionParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: single) :=
z_ConvolutionParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterfv_ovr_2(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_ConvolutionParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_ConvolutionParameteri_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: Int32);
external 'opengl32.dll' name 'glConvolutionParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteri(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: Int32) :=
z_ConvolutionParameteri_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameteriv_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glConvolutionParameteriv';
private static procedure z_ConvolutionParameteriv_ovr_0_anh0001(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ConvolutionParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_ConvolutionParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: Int32) :=
z_ConvolutionParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameteriv_ovr_2(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_ConvolutionParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_CopyConvolutionFilter1D_ovr_0(target: ConvolutionTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyConvolutionFilter1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter1D(target: ConvolutionTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32) :=
z_CopyConvolutionFilter1D_ovr_0(target, _internalformat, x, y, width);
private static procedure z_CopyConvolutionFilter2D_ovr_0(target: ConvolutionTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyConvolutionFilter2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter2D(target: ConvolutionTarget; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyConvolutionFilter2D_ovr_0(target, _internalformat, x, y, width, height);
private static procedure z_GetConvolutionFilter_ovr_0(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionFilter';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionFilter(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_GetConvolutionFilter_ovr_0(target, format, &type, image);
private static procedure z_GetConvolutionParameterfv_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetConvolutionParameterfv';
private static procedure z_GetConvolutionParameterfv_ovr_0_anh0001(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetConvolutionParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_GetConvolutionParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: single) :=
z_GetConvolutionParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetConvolutionParameterfv_ovr_2(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_GetConvolutionParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_GetConvolutionParameteriv_ovr_0(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetConvolutionParameteriv';
private static procedure z_GetConvolutionParameteriv_ovr_0_anh0001(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetConvolutionParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetConvolutionParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; var ¶ms: Int32) :=
z_GetConvolutionParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetConvolutionParameteriv_ovr_2(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameteriv(target: ConvolutionTarget; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_GetConvolutionParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_GetSeparableFilter_ovr_0(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr);
external 'opengl32.dll' name 'glGetSeparableFilter';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSeparableFilter(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr) :=
z_GetSeparableFilter_ovr_0(target, format, &type, row, column, span);
private static procedure z_SeparableFilter2D_ovr_0(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr);
external 'opengl32.dll' name 'glSeparableFilter2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SeparableFilter2D(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr) :=
z_SeparableFilter2D_ovr_0(target, _internalformat, width, height, format, &type, row, column);
private static procedure z_GetHistogram_ovr_0(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
external 'opengl32.dll' name 'glGetHistogram';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogram(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr) :=
z_GetHistogram_ovr_0(target, reset, format, &type, values);
private static procedure z_GetHistogramParameterfv_ovr_0(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetHistogramParameterfv';
private static procedure z_GetHistogramParameterfv_ovr_0_anh0001(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetHistogramParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_GetHistogramParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single) :=
z_GetHistogramParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetHistogramParameterfv_ovr_2(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr) :=
z_GetHistogramParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_GetHistogramParameteriv_ovr_0(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetHistogramParameteriv';
private static procedure z_GetHistogramParameteriv_ovr_0_anh0001(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameteriv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetHistogramParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetHistogramParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameteriv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32) :=
z_GetHistogramParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetHistogramParameteriv_ovr_2(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameteriv(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr) :=
z_GetHistogramParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_GetMinmax_ovr_0(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
external 'opengl32.dll' name 'glGetMinmax';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmax(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr) :=
z_GetMinmax_ovr_0(target, reset, format, &type, values);
private static procedure z_GetMinmaxParameterfv_ovr_0(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetMinmaxParameterfv';
private static procedure z_GetMinmaxParameterfv_ovr_0_anh0001(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMinmaxParameterfv_ovr_0(target, pname, ¶ms[0]) else
z_GetMinmaxParameterfv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single) :=
z_GetMinmaxParameterfv_ovr_0(target, pname, ¶ms);
private static procedure z_GetMinmaxParameterfv_ovr_2(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr) :=
z_GetMinmaxParameterfv_ovr_2(target, pname, ¶ms);
private static procedure z_GetMinmaxParameteriv_ovr_0(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMinmaxParameteriv';
private static procedure z_GetMinmaxParameteriv_ovr_0_anh0001(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameteriv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMinmaxParameteriv_ovr_0(target, pname, ¶ms[0]) else
z_GetMinmaxParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameteriv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32) :=
z_GetMinmaxParameteriv_ovr_0(target, pname, ¶ms);
private static procedure z_GetMinmaxParameteriv_ovr_2(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameteriv(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr) :=
z_GetMinmaxParameteriv_ovr_2(target, pname, ¶ms);
private static procedure z_Histogram_ovr_0(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean);
external 'opengl32.dll' name 'glHistogram';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Histogram(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean) :=
z_Histogram_ovr_0(target, width, _internalformat, sink);
private static procedure z_Minmax_ovr_0(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean);
external 'opengl32.dll' name 'glMinmax';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Minmax(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean) :=
z_Minmax_ovr_0(target, _internalformat, sink);
private static procedure z_ResetHistogram_ovr_0(target: HistogramTargetEXT);
external 'opengl32.dll' name 'glResetHistogram';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetHistogram(target: HistogramTargetEXT) :=
z_ResetHistogram_ovr_0(target);
private static procedure z_ResetMinmax_ovr_0(target: MinmaxTargetEXT);
external 'opengl32.dll' name 'glResetMinmax';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetMinmax(target: MinmaxTargetEXT) :=
z_ResetMinmax_ovr_0(target);
end;
[PCUNotRestore]
glIndirectParametersARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysIndirectCountARB_ovr_0(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysIndirectCountARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectCountARB(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32) :=
z_MultiDrawArraysIndirectCountARB_ovr_0(mode, indirect, drawcount, maxdrawcount, stride);
private static procedure z_MultiDrawElementsIndirectCountARB_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsIndirectCountARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectCountARB(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32) :=
z_MultiDrawElementsIndirectCountARB_ovr_0(mode, &type, indirect, drawcount, maxdrawcount, stride);
end;
[PCUNotRestore]
glInstancedArraysARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribDivisorARB_ovr_0(index: UInt32; divisor: UInt32);
external 'opengl32.dll' name 'glVertexAttribDivisorARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribDivisorARB(index: UInt32; divisor: UInt32) :=
z_VertexAttribDivisorARB_ovr_0(index, divisor);
end;
[PCUNotRestore]
glInternalformatQueryARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetInternalformativ_ovr_0(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetInternalformativ';
private static procedure z_GetInternalformativ_ovr_0_anh000001(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformativ';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms[0]) else
z_GetInternalformativ_ovr_0_anh000001(target, _internalformat, pname, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32) :=
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms);
private static procedure z_GetInternalformativ_ovr_2(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformativ';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr) :=
z_GetInternalformativ_ovr_2(target, _internalformat, pname, count, ¶ms);
end;
[PCUNotRestore]
glInternalformatQuery2ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetInternalformati64v_ovr_0(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetInternalformati64v';
private static procedure z_GetInternalformati64v_ovr_0_anh000001(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformati64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms[0]) else
z_GetInternalformati64v_ovr_0_anh000001(target, _internalformat, pname, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64) :=
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms);
private static procedure z_GetInternalformati64v_ovr_2(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformati64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr) :=
z_GetInternalformati64v_ovr_2(target, _internalformat, pname, count, ¶ms);
end;
[PCUNotRestore]
glInvalidateSubdataARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_InvalidateTexSubImage_ovr_0(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glInvalidateTexSubImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateTexSubImage(texture: TextureName; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32) :=
z_InvalidateTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth);
private static procedure z_InvalidateTexImage_ovr_0(texture: TextureName; level: Int32);
external 'opengl32.dll' name 'glInvalidateTexImage';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateTexImage(texture: TextureName; level: Int32) :=
z_InvalidateTexImage_ovr_0(texture, level);
private static procedure z_InvalidateBufferSubData_ovr_0(buffer: BufferName; offset: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glInvalidateBufferSubData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateBufferSubData(buffer: BufferName; offset: IntPtr; length: IntPtr) :=
z_InvalidateBufferSubData_ovr_0(buffer, offset, length);
private static procedure z_InvalidateBufferData_ovr_0(buffer: BufferName);
external 'opengl32.dll' name 'glInvalidateBufferData';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateBufferData(buffer: BufferName) :=
z_InvalidateBufferData_ovr_0(buffer);
private static procedure z_InvalidateFramebuffer_ovr_0(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment);
external 'opengl32.dll' name 'glInvalidateFramebuffer';
private static procedure z_InvalidateFramebuffer_ovr_0_anh0001(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr);
external 'opengl32.dll' name 'glInvalidateFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: array of InvalidateFramebufferAttachment) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments[0]) else
z_InvalidateFramebuffer_ovr_0_anh0001(target, numAttachments, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment) :=
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments);
private static procedure z_InvalidateFramebuffer_ovr_2(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr);
external 'opengl32.dll' name 'glInvalidateFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr) :=
z_InvalidateFramebuffer_ovr_2(target, numAttachments, attachments);
private static procedure z_InvalidateSubFramebuffer_ovr_0(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateSubFramebuffer';
private static procedure z_InvalidateSubFramebuffer_ovr_0_anh00010000(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateSubFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: array of InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
if (attachments<>nil) and (attachments.Length<>0) then
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments[0], x, y, width, height) else
z_InvalidateSubFramebuffer_ovr_0_anh00010000(target, numAttachments, IntPtr.Zero, x, y, width, height);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments, x, y, width, height);
private static procedure z_InvalidateSubFramebuffer_ovr_2(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glInvalidateSubFramebuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_InvalidateSubFramebuffer_ovr_2(target, numAttachments, attachments, x, y, width, height);
end;
[PCUNotRestore]
glMapBufferRangeARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_MapBufferRange_ovr_0(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr;
external 'opengl32.dll' name 'glMapBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
z_MapBufferRange_ovr_0(target, offset, length, access);
private static procedure z_FlushMappedBufferRange_ovr_0(target: BufferTargetARB; offset: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glFlushMappedBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr) :=
z_FlushMappedBufferRange_ovr_0(target, offset, length);
end;
[PCUNotRestore]
glMatrixPaletteARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CurrentPaletteMatrixARB_ovr_0(index: Int32);
external 'opengl32.dll' name 'glCurrentPaletteMatrixARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CurrentPaletteMatrixARB(index: Int32) :=
z_CurrentPaletteMatrixARB_ovr_0(index);
private static procedure z_MatrixIndexubvARB_ovr_0(size: Int32; var indices: Byte);
external 'opengl32.dll' name 'glMatrixIndexubvARB';
private static procedure z_MatrixIndexubvARB_ovr_0_anh001(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; indices: array of Byte) :=
if (indices<>nil) and (indices.Length<>0) then
z_MatrixIndexubvARB_ovr_0(size, indices[0]) else
z_MatrixIndexubvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; var indices: Byte) :=
z_MatrixIndexubvARB_ovr_0(size, indices);
private static procedure z_MatrixIndexubvARB_ovr_2(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; indices: IntPtr) :=
z_MatrixIndexubvARB_ovr_2(size, indices);
private static procedure z_MatrixIndexusvARB_ovr_0(size: Int32; var indices: UInt16);
external 'opengl32.dll' name 'glMatrixIndexusvARB';
private static procedure z_MatrixIndexusvARB_ovr_0_anh001(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; indices: array of UInt16) :=
if (indices<>nil) and (indices.Length<>0) then
z_MatrixIndexusvARB_ovr_0(size, indices[0]) else
z_MatrixIndexusvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; var indices: UInt16) :=
z_MatrixIndexusvARB_ovr_0(size, indices);
private static procedure z_MatrixIndexusvARB_ovr_2(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; indices: IntPtr) :=
z_MatrixIndexusvARB_ovr_2(size, indices);
private static procedure z_MatrixIndexuivARB_ovr_0(size: Int32; var indices: UInt32);
external 'opengl32.dll' name 'glMatrixIndexuivARB';
private static procedure z_MatrixIndexuivARB_ovr_0_anh001(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; indices: array of UInt32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MatrixIndexuivARB_ovr_0(size, indices[0]) else
z_MatrixIndexuivARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; var indices: UInt32) :=
z_MatrixIndexuivARB_ovr_0(size, indices);
private static procedure z_MatrixIndexuivARB_ovr_2(size: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; indices: IntPtr) :=
z_MatrixIndexuivARB_ovr_2(size, indices);
private static procedure z_MatrixIndexPointerARB_ovr_0(size: Int32; &type: MatrixIndexPointerTypeARB; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glMatrixIndexPointerARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexPointerARB(size: Int32; &type: MatrixIndexPointerTypeARB; stride: Int32; pointer: IntPtr) :=
z_MatrixIndexPointerARB_ovr_0(size, &type, stride, pointer);
end;
[PCUNotRestore]
glMultiBindARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindBuffersBase_ovr_0(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32);
external 'opengl32.dll' name 'glBindBuffersBase';
private static procedure z_BindBuffersBase_ovr_0_anh00001(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glBindBuffersBase';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersBase_ovr_0(target, first, count, buffers[0]) else
z_BindBuffersBase_ovr_0_anh00001(target, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32) :=
z_BindBuffersBase_ovr_0(target, first, count, buffers);
private static procedure z_BindBuffersBase_ovr_2(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glBindBuffersBase';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr) :=
z_BindBuffersBase_ovr_2(target, first, count, buffers);
private static procedure z_BindBuffersRange_ovr_0(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000110(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000101(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000011(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_0_anh0000111(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000111(target, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindBuffersRange_ovr_1_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_1_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_1_anh0000110(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_2(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_2_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_2_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_2_anh0000110(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers[0], IntPtr.Zero, sizes) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_3_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_3_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_3_anh0000101(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers[0], offsets, IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_BindBuffersRange_ovr_4_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_5_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_6(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_6_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_6_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_6_anh0000101(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; sizes: array of IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers[0], offsets, IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_BindBuffersRange_ovr_7_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var sizes: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_8(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_8_anh0000100(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; sizes: pointer) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindBuffersRange_ovr_8(target, first, count, buffers[0], offsets, sizes) else
z_BindBuffersRange_ovr_8_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_9_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_9_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_9_anh0000011(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindBuffersRange_ovr_10_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var sizes: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_11_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: pointer) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_12_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: pointer) :=
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_15_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: pointer) :=
z_BindBuffersRange_ovr_8(target, first, count, buffers, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_18(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_18_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_18_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_18_anh0000011(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets[0], IntPtr.Zero) else
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindBuffersRange_ovr_19_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_20(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_20_anh0000010(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets[0], sizes) else
z_BindBuffersRange_ovr_20_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
private static procedure z_BindBuffersRange_ovr_21_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_24(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
private static procedure z_BindBuffersRange_ovr_24_anh0000001(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes[0]) else
z_BindBuffersRange_ovr_24_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes);
private static procedure z_BindBuffersRange_ovr_26(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer);
external 'opengl32.dll' name 'glBindBuffersRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
z_BindBuffersRange_ovr_26(target, first, count, buffers, offsets, sizes);
private static procedure z_BindTextures_ovr_0(first: UInt32; count: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glBindTextures';
private static procedure z_BindTextures_ovr_0_anh0001(first: UInt32; count: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glBindTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_BindTextures_ovr_0(first, count, textures[0]) else
z_BindTextures_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; var textures: UInt32) :=
z_BindTextures_ovr_0(first, count, textures);
private static procedure z_BindTextures_ovr_2(first: UInt32; count: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glBindTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; textures: IntPtr) :=
z_BindTextures_ovr_2(first, count, textures);
private static procedure z_BindSamplers_ovr_0(first: UInt32; count: Int32; var samplers: UInt32);
external 'opengl32.dll' name 'glBindSamplers';
private static procedure z_BindSamplers_ovr_0_anh0001(first: UInt32; count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glBindSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_BindSamplers_ovr_0(first, count, samplers[0]) else
z_BindSamplers_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; var samplers: UInt32) :=
z_BindSamplers_ovr_0(first, count, samplers);
private static procedure z_BindSamplers_ovr_2(first: UInt32; count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glBindSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; samplers: IntPtr) :=
z_BindSamplers_ovr_2(first, count, samplers);
private static procedure z_BindImageTextures_ovr_0(first: UInt32; count: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glBindImageTextures';
private static procedure z_BindImageTextures_ovr_0_anh0001(first: UInt32; count: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glBindImageTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_BindImageTextures_ovr_0(first, count, textures[0]) else
z_BindImageTextures_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; var textures: UInt32) :=
z_BindImageTextures_ovr_0(first, count, textures);
private static procedure z_BindImageTextures_ovr_2(first: UInt32; count: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glBindImageTextures';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; textures: IntPtr) :=
z_BindImageTextures_ovr_2(first, count, textures);
private static procedure z_BindVertexBuffers_ovr_0(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000110(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000001(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000101(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000011(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_0_anh000111(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers[0], offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers[0], IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000011(first, count, buffers[0], IntPtr.Zero, IntPtr.Zero) else
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000101(first, count, IntPtr.Zero, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000111(first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindVertexBuffers_ovr_1_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_1_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_1_anh000110(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides);
private static procedure z_BindVertexBuffers_ovr_2(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_2_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_2_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_2_anh000110(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000010(first, count, buffers[0], IntPtr.Zero, strides) else
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2_anh000100(first, count, IntPtr.Zero, offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000110(first, count, IntPtr.Zero, IntPtr.Zero, strides);
private static procedure z_BindVertexBuffers_ovr_3_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_3_anh000101(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000101(first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_BindVertexBuffers_ovr_4_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_0_anh000100(first, count, IntPtr.Zero, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_5_anh000100(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_2_anh000100(first, count, IntPtr.Zero, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_6(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_6_anh000100(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_6_anh000001(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_6_anh000101(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: array of Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000001(first, count, buffers[0], offsets, IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6_anh000100(first, count, IntPtr.Zero, offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000101(first, count, IntPtr.Zero, offsets, IntPtr.Zero);
private static procedure z_BindVertexBuffers_ovr_7_anh000100(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_6_anh000100(first, count, IntPtr.Zero, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_8(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_8_anh000100(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_BindVertexBuffers_ovr_8(first, count, buffers[0], offsets, strides) else
z_BindVertexBuffers_ovr_8_anh000100(first, count, IntPtr.Zero, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_9_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_9_anh000011(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000011(first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindVertexBuffers_ovr_10_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_0_anh000010(first, count, buffers, IntPtr.Zero, strides);
private static procedure z_BindVertexBuffers_ovr_11_anh000010(first: UInt32; count: Int32; var buffers: UInt32; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_2_anh000010(first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_0_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32) :=
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr) :=
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_6_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32) :=
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr) :=
z_BindVertexBuffers_ovr_8(first, count, buffers, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_18(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_18_anh000010(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_18_anh000001(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_18_anh000011(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: array of Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides[0]) else
z_BindVertexBuffers_ovr_18_anh000001(first, count, buffers, offsets[0], IntPtr.Zero) else
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18_anh000010(first, count, buffers, IntPtr.Zero, strides[0]) else
z_BindVertexBuffers_ovr_18_anh000011(first, count, buffers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_BindVertexBuffers_ovr_19_anh000010(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_18_anh000010(first, count, buffers, IntPtr.Zero, strides);
private static procedure z_BindVertexBuffers_ovr_20(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_20_anh000010(first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; strides: IntPtr) :=
if (offsets<>nil) and (offsets.Length<>0) then
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets[0], strides) else
z_BindVertexBuffers_ovr_20_anh000010(first, count, buffers, IntPtr.Zero, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_18_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32) :=
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr) :=
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_24(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
external 'opengl32.dll' name 'glBindVertexBuffers';
private static procedure z_BindVertexBuffers_ovr_24_anh000001(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: array of Int32) :=
if (strides<>nil) and (strides.Length<>0) then
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides[0]) else
z_BindVertexBuffers_ovr_24_anh000001(first, count, buffers, offsets, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32) :=
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides);
private static procedure z_BindVertexBuffers_ovr_26(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr);
external 'opengl32.dll' name 'glBindVertexBuffers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; strides: IntPtr) :=
z_BindVertexBuffers_ovr_26(first, count, buffers, offsets, strides);
end;
[PCUNotRestore]
glMultiDrawIndirectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysIndirect_ovr_0(mode: PrimitiveType; indirect: IntPtr; drawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysIndirect';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirect(mode: PrimitiveType; indirect: IntPtr; drawcount: Int32; stride: Int32) :=
z_MultiDrawArraysIndirect_ovr_0(mode, indirect, drawcount, stride);
private static procedure z_MultiDrawElementsIndirect_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsIndirect';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirect(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: Int32; stride: Int32) :=
z_MultiDrawElementsIndirect_ovr_0(mode, &type, indirect, drawcount, stride);
end;
[PCUNotRestore]
glMultisampleARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SampleCoverageARB_ovr_0(value: single; invert: boolean);
external 'opengl32.dll' name 'glSampleCoverageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleCoverageARB(value: single; invert: boolean) :=
z_SampleCoverageARB_ovr_0(value, invert);
end;
[PCUNotRestore]
glMultitextureARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ActiveTextureARB_ovr_0(texture: TextureUnit);
external 'opengl32.dll' name 'glActiveTextureARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveTextureARB(texture: TextureUnit) :=
z_ActiveTextureARB_ovr_0(texture);
private static procedure z_ClientActiveTextureARB_ovr_0(texture: TextureUnit);
external 'opengl32.dll' name 'glClientActiveTextureARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveTextureARB(texture: TextureUnit) :=
z_ClientActiveTextureARB_ovr_0(texture);
private static procedure z_MultiTexCoord1dARB_ovr_0(target: TextureUnit; s: real);
external 'opengl32.dll' name 'glMultiTexCoord1dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dARB(target: TextureUnit; s: real) :=
z_MultiTexCoord1dARB_ovr_0(target, s);
private static procedure z_MultiTexCoord1dvARB_ovr_0(target: TextureUnit; var v: real);
external 'opengl32.dll' name 'glMultiTexCoord1dvARB';
private static procedure z_MultiTexCoord1dvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1dvARB_ovr_0(target, v[0]) else
z_MultiTexCoord1dvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; var v: real) :=
z_MultiTexCoord1dvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord1dvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1dvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord1fARB_ovr_0(target: TextureUnit; s: single);
external 'opengl32.dll' name 'glMultiTexCoord1fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fARB(target: TextureUnit; s: single) :=
z_MultiTexCoord1fARB_ovr_0(target, s);
private static procedure z_MultiTexCoord1fvARB_ovr_0(target: TextureUnit; var v: single);
external 'opengl32.dll' name 'glMultiTexCoord1fvARB';
private static procedure z_MultiTexCoord1fvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1fvARB_ovr_0(target, v[0]) else
z_MultiTexCoord1fvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; var v: single) :=
z_MultiTexCoord1fvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord1fvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1fvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord1iARB_ovr_0(target: TextureUnit; s: Int32);
external 'opengl32.dll' name 'glMultiTexCoord1iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iARB(target: TextureUnit; s: Int32) :=
z_MultiTexCoord1iARB_ovr_0(target, s);
private static procedure z_MultiTexCoord1ivARB_ovr_0(target: TextureUnit; var v: Int32);
external 'opengl32.dll' name 'glMultiTexCoord1ivARB';
private static procedure z_MultiTexCoord1ivARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1ivARB_ovr_0(target, v[0]) else
z_MultiTexCoord1ivARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord1ivARB_ovr_0(target, v);
private static procedure z_MultiTexCoord1ivARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1ivARB_ovr_2(target, v);
private static procedure z_MultiTexCoord1sARB_ovr_0(target: TextureUnit; s: Int16);
external 'opengl32.dll' name 'glMultiTexCoord1sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sARB(target: TextureUnit; s: Int16) :=
z_MultiTexCoord1sARB_ovr_0(target, s);
private static procedure z_MultiTexCoord1svARB_ovr_0(target: TextureUnit; var v: Int16);
external 'opengl32.dll' name 'glMultiTexCoord1svARB';
private static procedure z_MultiTexCoord1svARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1svARB_ovr_0(target, v[0]) else
z_MultiTexCoord1svARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord1svARB_ovr_0(target, v);
private static procedure z_MultiTexCoord1svARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1svARB_ovr_2(target, v);
private static procedure z_MultiTexCoord2dARB_ovr_0(target: TextureUnit; s: real; t: real);
external 'opengl32.dll' name 'glMultiTexCoord2dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dARB(target: TextureUnit; s: real; t: real) :=
z_MultiTexCoord2dARB_ovr_0(target, s, t);
private static procedure z_MultiTexCoord2dvARB_ovr_0(target: TextureUnit; var v: real);
external 'opengl32.dll' name 'glMultiTexCoord2dvARB';
private static procedure z_MultiTexCoord2dvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2dvARB_ovr_0(target, v[0]) else
z_MultiTexCoord2dvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; var v: real) :=
z_MultiTexCoord2dvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord2dvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2dvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord2fARB_ovr_0(target: TextureUnit; s: single; t: single);
external 'opengl32.dll' name 'glMultiTexCoord2fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fARB(target: TextureUnit; s: single; t: single) :=
z_MultiTexCoord2fARB_ovr_0(target, s, t);
private static procedure z_MultiTexCoord2fvARB_ovr_0(target: TextureUnit; var v: single);
external 'opengl32.dll' name 'glMultiTexCoord2fvARB';
private static procedure z_MultiTexCoord2fvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2fvARB_ovr_0(target, v[0]) else
z_MultiTexCoord2fvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; var v: single) :=
z_MultiTexCoord2fvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord2fvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2fvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord2iARB_ovr_0(target: TextureUnit; s: Int32; t: Int32);
external 'opengl32.dll' name 'glMultiTexCoord2iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iARB(target: TextureUnit; s: Int32; t: Int32) :=
z_MultiTexCoord2iARB_ovr_0(target, s, t);
private static procedure z_MultiTexCoord2ivARB_ovr_0(target: TextureUnit; var v: Int32);
external 'opengl32.dll' name 'glMultiTexCoord2ivARB';
private static procedure z_MultiTexCoord2ivARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2ivARB_ovr_0(target, v[0]) else
z_MultiTexCoord2ivARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord2ivARB_ovr_0(target, v);
private static procedure z_MultiTexCoord2ivARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2ivARB_ovr_2(target, v);
private static procedure z_MultiTexCoord2sARB_ovr_0(target: TextureUnit; s: Int16; t: Int16);
external 'opengl32.dll' name 'glMultiTexCoord2sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sARB(target: TextureUnit; s: Int16; t: Int16) :=
z_MultiTexCoord2sARB_ovr_0(target, s, t);
private static procedure z_MultiTexCoord2svARB_ovr_0(target: TextureUnit; var v: Int16);
external 'opengl32.dll' name 'glMultiTexCoord2svARB';
private static procedure z_MultiTexCoord2svARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2svARB_ovr_0(target, v[0]) else
z_MultiTexCoord2svARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord2svARB_ovr_0(target, v);
private static procedure z_MultiTexCoord2svARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2svARB_ovr_2(target, v);
private static procedure z_MultiTexCoord3dARB_ovr_0(target: TextureUnit; s: real; t: real; r: real);
external 'opengl32.dll' name 'glMultiTexCoord3dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dARB(target: TextureUnit; s: real; t: real; r: real) :=
z_MultiTexCoord3dARB_ovr_0(target, s, t, r);
private static procedure z_MultiTexCoord3dvARB_ovr_0(target: TextureUnit; var v: real);
external 'opengl32.dll' name 'glMultiTexCoord3dvARB';
private static procedure z_MultiTexCoord3dvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3dvARB_ovr_0(target, v[0]) else
z_MultiTexCoord3dvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; var v: real) :=
z_MultiTexCoord3dvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord3dvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3dvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord3fARB_ovr_0(target: TextureUnit; s: single; t: single; r: single);
external 'opengl32.dll' name 'glMultiTexCoord3fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fARB(target: TextureUnit; s: single; t: single; r: single) :=
z_MultiTexCoord3fARB_ovr_0(target, s, t, r);
private static procedure z_MultiTexCoord3fvARB_ovr_0(target: TextureUnit; var v: single);
external 'opengl32.dll' name 'glMultiTexCoord3fvARB';
private static procedure z_MultiTexCoord3fvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3fvARB_ovr_0(target, v[0]) else
z_MultiTexCoord3fvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; var v: single) :=
z_MultiTexCoord3fvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord3fvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3fvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord3iARB_ovr_0(target: TextureUnit; s: Int32; t: Int32; r: Int32);
external 'opengl32.dll' name 'glMultiTexCoord3iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iARB(target: TextureUnit; s: Int32; t: Int32; r: Int32) :=
z_MultiTexCoord3iARB_ovr_0(target, s, t, r);
private static procedure z_MultiTexCoord3ivARB_ovr_0(target: TextureUnit; var v: Int32);
external 'opengl32.dll' name 'glMultiTexCoord3ivARB';
private static procedure z_MultiTexCoord3ivARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3ivARB_ovr_0(target, v[0]) else
z_MultiTexCoord3ivARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord3ivARB_ovr_0(target, v);
private static procedure z_MultiTexCoord3ivARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3ivARB_ovr_2(target, v);
private static procedure z_MultiTexCoord3sARB_ovr_0(target: TextureUnit; s: Int16; t: Int16; r: Int16);
external 'opengl32.dll' name 'glMultiTexCoord3sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sARB(target: TextureUnit; s: Int16; t: Int16; r: Int16) :=
z_MultiTexCoord3sARB_ovr_0(target, s, t, r);
private static procedure z_MultiTexCoord3svARB_ovr_0(target: TextureUnit; var v: Int16);
external 'opengl32.dll' name 'glMultiTexCoord3svARB';
private static procedure z_MultiTexCoord3svARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3svARB_ovr_0(target, v[0]) else
z_MultiTexCoord3svARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord3svARB_ovr_0(target, v);
private static procedure z_MultiTexCoord3svARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3svARB_ovr_2(target, v);
private static procedure z_MultiTexCoord4dARB_ovr_0(target: TextureUnit; s: real; t: real; r: real; q: real);
external 'opengl32.dll' name 'glMultiTexCoord4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dARB(target: TextureUnit; s: real; t: real; r: real; q: real) :=
z_MultiTexCoord4dARB_ovr_0(target, s, t, r, q);
private static procedure z_MultiTexCoord4dvARB_ovr_0(target: TextureUnit; var v: real);
external 'opengl32.dll' name 'glMultiTexCoord4dvARB';
private static procedure z_MultiTexCoord4dvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4dvARB_ovr_0(target, v[0]) else
z_MultiTexCoord4dvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; var v: real) :=
z_MultiTexCoord4dvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord4dvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4dvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord4fARB_ovr_0(target: TextureUnit; s: single; t: single; r: single; q: single);
external 'opengl32.dll' name 'glMultiTexCoord4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fARB(target: TextureUnit; s: single; t: single; r: single; q: single) :=
z_MultiTexCoord4fARB_ovr_0(target, s, t, r, q);
private static procedure z_MultiTexCoord4fvARB_ovr_0(target: TextureUnit; var v: single);
external 'opengl32.dll' name 'glMultiTexCoord4fvARB';
private static procedure z_MultiTexCoord4fvARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4fvARB_ovr_0(target, v[0]) else
z_MultiTexCoord4fvARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; var v: single) :=
z_MultiTexCoord4fvARB_ovr_0(target, v);
private static procedure z_MultiTexCoord4fvARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4fvARB_ovr_2(target, v);
private static procedure z_MultiTexCoord4iARB_ovr_0(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32);
external 'opengl32.dll' name 'glMultiTexCoord4iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iARB(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32) :=
z_MultiTexCoord4iARB_ovr_0(target, s, t, r, q);
private static procedure z_MultiTexCoord4ivARB_ovr_0(target: TextureUnit; var v: Int32);
external 'opengl32.dll' name 'glMultiTexCoord4ivARB';
private static procedure z_MultiTexCoord4ivARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4ivARB_ovr_0(target, v[0]) else
z_MultiTexCoord4ivARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; var v: Int32) :=
z_MultiTexCoord4ivARB_ovr_0(target, v);
private static procedure z_MultiTexCoord4ivARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4ivARB_ovr_2(target, v);
private static procedure z_MultiTexCoord4sARB_ovr_0(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16);
external 'opengl32.dll' name 'glMultiTexCoord4sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sARB(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16) :=
z_MultiTexCoord4sARB_ovr_0(target, s, t, r, q);
private static procedure z_MultiTexCoord4svARB_ovr_0(target: TextureUnit; var v: Int16);
external 'opengl32.dll' name 'glMultiTexCoord4svARB';
private static procedure z_MultiTexCoord4svARB_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4svARB_ovr_0(target, v[0]) else
z_MultiTexCoord4svARB_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; var v: Int16) :=
z_MultiTexCoord4svARB_ovr_0(target, v);
private static procedure z_MultiTexCoord4svARB_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4svARB_ovr_2(target, v);
end;
[PCUNotRestore]
glOcclusionQueryARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenQueriesARB_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glGenQueriesARB';
private static procedure z_GenQueriesARB_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenQueriesARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenQueriesARB_ovr_0(n, ids[0]) else
z_GenQueriesARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; var ids: UInt32) :=
z_GenQueriesARB_ovr_0(n, ids);
private static procedure z_GenQueriesARB_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenQueriesARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; ids: IntPtr) :=
z_GenQueriesARB_ovr_2(n, ids);
private static procedure z_DeleteQueriesARB_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glDeleteQueriesARB';
private static procedure z_DeleteQueriesARB_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteQueriesARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteQueriesARB_ovr_0(n, ids[0]) else
z_DeleteQueriesARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; var ids: UInt32) :=
z_DeleteQueriesARB_ovr_0(n, ids);
private static procedure z_DeleteQueriesARB_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteQueriesARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; ids: IntPtr) :=
z_DeleteQueriesARB_ovr_2(n, ids);
private static function z_IsQueryARB_ovr_0(id: UInt32): boolean;
external 'opengl32.dll' name 'glIsQueryARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsQueryARB(id: UInt32): boolean :=
z_IsQueryARB_ovr_0(id);
private static procedure z_BeginQueryARB_ovr_0(target: DummyEnum; id: UInt32);
external 'opengl32.dll' name 'glBeginQueryARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQueryARB(target: DummyEnum; id: UInt32) :=
z_BeginQueryARB_ovr_0(target, id);
private static procedure z_EndQueryARB_ovr_0(target: QueryTarget);
external 'opengl32.dll' name 'glEndQueryARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQueryARB(target: QueryTarget) :=
z_EndQueryARB_ovr_0(target);
private static procedure z_GetQueryivARB_ovr_0(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetQueryivARB';
private static procedure z_GetQueryivARB_ovr_0_anh0001(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryivARB_ovr_0(target, pname, ¶ms[0]) else
z_GetQueryivARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32) :=
z_GetQueryivARB_ovr_0(target, pname, ¶ms);
private static procedure z_GetQueryivARB_ovr_2(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr) :=
z_GetQueryivARB_ovr_2(target, pname, ¶ms);
private static procedure z_GetQueryObjectivARB_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetQueryObjectivARB';
private static procedure z_GetQueryObjectivARB_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectivARB_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectivARB_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32) :=
z_GetQueryObjectivARB_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjectivARB_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectivARB_ovr_2(id, pname, ¶ms);
private static procedure z_GetQueryObjectuivARB_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetQueryObjectuivARB';
private static procedure z_GetQueryObjectuivARB_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectuivARB_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectuivARB_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32) :=
z_GetQueryObjectuivARB_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjectuivARB_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectuivARB_ovr_2(id, pname, ¶ms);
end;
[PCUNotRestore]
glParallelShaderCompileARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MaxShaderCompilerThreadsARB_ovr_0(count: UInt32);
external 'opengl32.dll' name 'glMaxShaderCompilerThreadsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaxShaderCompilerThreadsARB(count: UInt32) :=
z_MaxShaderCompilerThreadsARB_ovr_0(count);
end;
[PCUNotRestore]
glPointParametersARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PointParameterfARB_ovr_0(pname: PointParameterNameARB; param: single);
external 'opengl32.dll' name 'glPointParameterfARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfARB(pname: PointParameterNameARB; param: single) :=
z_PointParameterfARB_ovr_0(pname, param);
private static procedure z_PointParameterfvARB_ovr_0(pname: PointParameterNameARB; var ¶ms: single);
external 'opengl32.dll' name 'glPointParameterfvARB';
private static procedure z_PointParameterfvARB_ovr_0_anh001(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterfvARB_ovr_0(pname, ¶ms[0]) else
z_PointParameterfvARB_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; var ¶ms: single) :=
z_PointParameterfvARB_ovr_0(pname, ¶ms);
private static procedure z_PointParameterfvARB_ovr_2(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterfvARB_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glPolygonOffsetClampARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PolygonOffsetClamp_ovr_0(factor: single; units: single; clamp: single);
external 'opengl32.dll' name 'glPolygonOffsetClamp';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetClamp(factor: single; units: single; clamp: single) :=
z_PolygonOffsetClamp_ovr_0(factor, units, clamp);
end;
[PCUNotRestore]
glProgramInterfaceQueryARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetProgramInterfaceiv_ovr_0(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramInterfaceiv';
private static procedure z_GetProgramInterfaceiv_ovr_0_anh00001(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramInterfaceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms[0]) else
z_GetProgramInterfaceiv_ovr_0_anh00001(&program, _programInterface, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32) :=
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms);
private static procedure z_GetProgramInterfaceiv_ovr_2(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramInterfaceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: IntPtr) :=
z_GetProgramInterfaceiv_ovr_2(&program, _programInterface, pname, ¶ms);
private static function z_GetProgramResourceIndex_ovr_0(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetProgramResourceIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceIndex(&program: ProgramName; _programInterface: ProgramInterface; name: string): UInt32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceIndex_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceIndex(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): UInt32 :=
z_GetProgramResourceIndex_ovr_0(&program, _programInterface, name);
private static procedure z_GetProgramResourceName_ovr_0(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceName';
private static procedure z_GetProgramResourceName_ovr_0_anh0000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length[0], name) else
z_GetProgramResourceName_ovr_0_anh0000010(&program, _programInterface, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length, name);
private static procedure z_GetProgramResourceName_ovr_2(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetProgramResourceName_ovr_2(&program, _programInterface, index, bufSize, length, name);
private static procedure z_GetProgramResourceiv_ovr_0(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000000011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_0_anh000001011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000011(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001011(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramResourceiv_ovr_1_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_1_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_1_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_2(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_2_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_2_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_2_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_3_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_3_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private static procedure z_GetProgramResourceiv_ovr_4_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_5_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_6(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_6_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_6_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_6_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private static procedure z_GetProgramResourceiv_ovr_7_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_8(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_8_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourceiv_ovr_8_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_2_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_6_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_18(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_18_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_18_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_18_anh000000011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramResourceiv_ovr_19_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; var ¶ms: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_20(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_20_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourceiv_ovr_20_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_24(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramResourceiv';
private static procedure z_GetProgramResourceiv_ovr_24_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourceiv_ovr_24_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32) :=
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourceiv_ovr_26(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourceiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourceiv_ovr_26(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static function z_GetProgramResourceLocation_ovr_0(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetProgramResourceLocation';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocation(&program: ProgramName; _programInterface: ProgramInterface; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceLocation_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocation(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32 :=
z_GetProgramResourceLocation_ovr_0(&program, _programInterface, name);
private static function z_GetProgramResourceLocationIndex_ovr_0(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetProgramResourceLocationIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocationIndex(&program: ProgramName; _programInterface: ProgramInterface; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetProgramResourceLocationIndex_ovr_0(&program, _programInterface, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetProgramResourceLocationIndex(&program: ProgramName; _programInterface: ProgramInterface; name: IntPtr): Int32 :=
z_GetProgramResourceLocationIndex_ovr_0(&program, _programInterface, name);
end;
[PCUNotRestore]
glProvokingVertexARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProvokingVertex_ovr_0(mode: VertexProvokingMode);
external 'opengl32.dll' name 'glProvokingVertex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProvokingVertex(mode: VertexProvokingMode) :=
z_ProvokingVertex_ovr_0(mode);
end;
[PCUNotRestore]
glRobustnessARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetGraphicsResetStatusARB_ovr_0: GraphicsResetStatus;
external 'opengl32.dll' name 'glGetGraphicsResetStatusARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetGraphicsResetStatusARB: GraphicsResetStatus :=
z_GetGraphicsResetStatusARB_ovr_0;
private static procedure z_GetnTexImageARB_ovr_0(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; img: IntPtr);
external 'opengl32.dll' name 'glGetnTexImageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnTexImageARB(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; img: IntPtr) :=
z_GetnTexImageARB_ovr_0(target, level, format, &type, bufSize, img);
private static procedure z_ReadnPixelsARB_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glReadnPixelsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadnPixelsARB(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr) :=
z_ReadnPixelsARB_ovr_0(x, y, width, height, format, &type, bufSize, data);
private static procedure z_GetnCompressedTexImageARB_ovr_0(target: TextureTarget; lod: Int32; bufSize: Int32; img: IntPtr);
external 'opengl32.dll' name 'glGetnCompressedTexImageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnCompressedTexImageARB(target: TextureTarget; lod: Int32; bufSize: Int32; img: IntPtr) :=
z_GetnCompressedTexImageARB_ovr_0(target, lod, bufSize, img);
private static procedure z_GetnUniformfvARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetnUniformfvARB';
private static procedure z_GetnUniformfvARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformfvARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformfvARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: single) :=
z_GetnUniformfvARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformfvARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformfvARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformivARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetnUniformivARB';
private static procedure z_GetnUniformivARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformivARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformivARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int32) :=
z_GetnUniformivARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformivARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformivARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformuivARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetnUniformuivARB';
private static procedure z_GetnUniformuivARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformuivARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformuivARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt32) :=
z_GetnUniformuivARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformuivARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformuivARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformdvARB_ovr_0(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: real);
external 'opengl32.dll' name 'glGetnUniformdvARB';
private static procedure z_GetnUniformdvARB_ovr_0_anh00001(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformdvARB_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformdvARB_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: real) :=
z_GetnUniformdvARB_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformdvARB_ovr_2(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformdvARB_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnMapdvARB_ovr_0(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real);
external 'opengl32.dll' name 'glGetnMapdvARB';
private static procedure z_GetnMapdvARB_ovr_0_anh00001(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapdvARB_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapdvARB_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real) :=
z_GetnMapdvARB_ovr_0(target, query, bufSize, v);
private static procedure z_GetnMapdvARB_ovr_2(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapdvARB_ovr_2(target, query, bufSize, v);
private static procedure z_GetnMapfvARB_ovr_0(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single);
external 'opengl32.dll' name 'glGetnMapfvARB';
private static procedure z_GetnMapfvARB_ovr_0_anh00001(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapfvARB_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapfvARB_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single) :=
z_GetnMapfvARB_ovr_0(target, query, bufSize, v);
private static procedure z_GetnMapfvARB_ovr_2(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapfvARB_ovr_2(target, query, bufSize, v);
private static procedure z_GetnMapivARB_ovr_0(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32);
external 'opengl32.dll' name 'glGetnMapivARB';
private static procedure z_GetnMapivARB_ovr_0_anh00001(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_GetnMapivARB_ovr_0(target, query, bufSize, v[0]) else
z_GetnMapivARB_ovr_0_anh00001(target, query, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32) :=
z_GetnMapivARB_ovr_0(target, query, bufSize, v);
private static procedure z_GetnMapivARB_ovr_2(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetnMapivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr) :=
z_GetnMapivARB_ovr_2(target, query, bufSize, v);
private static procedure z_GetnPixelMapfvARB_ovr_0(map: PixelMap; bufSize: Int32; var values: single);
external 'opengl32.dll' name 'glGetnPixelMapfvARB';
private static procedure z_GetnPixelMapfvARB_ovr_0_anh0001(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapfvARB_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapfvARB_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; var values: single) :=
z_GetnPixelMapfvARB_ovr_0(map, bufSize, values);
private static procedure z_GetnPixelMapfvARB_ovr_2(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapfvARB_ovr_2(map, bufSize, values);
private static procedure z_GetnPixelMapuivARB_ovr_0(map: PixelMap; bufSize: Int32; var values: UInt32);
external 'opengl32.dll' name 'glGetnPixelMapuivARB';
private static procedure z_GetnPixelMapuivARB_ovr_0_anh0001(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; values: array of UInt32) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapuivARB_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapuivARB_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; var values: UInt32) :=
z_GetnPixelMapuivARB_ovr_0(map, bufSize, values);
private static procedure z_GetnPixelMapuivARB_ovr_2(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapuivARB_ovr_2(map, bufSize, values);
private static procedure z_GetnPixelMapusvARB_ovr_0(map: PixelMap; bufSize: Int32; var values: UInt16);
external 'opengl32.dll' name 'glGetnPixelMapusvARB';
private static procedure z_GetnPixelMapusvARB_ovr_0_anh0001(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; values: array of UInt16) :=
if (values<>nil) and (values.Length<>0) then
z_GetnPixelMapusvARB_ovr_0(map, bufSize, values[0]) else
z_GetnPixelMapusvARB_ovr_0_anh0001(map, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; var values: UInt16) :=
z_GetnPixelMapusvARB_ovr_0(map, bufSize, values);
private static procedure z_GetnPixelMapusvARB_ovr_2(map: PixelMap; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnPixelMapusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; values: IntPtr) :=
z_GetnPixelMapusvARB_ovr_2(map, bufSize, values);
private static procedure z_GetnPolygonStippleARB_ovr_0(bufSize: Int32; var pattern: Byte);
external 'opengl32.dll' name 'glGetnPolygonStippleARB';
private static procedure z_GetnPolygonStippleARB_ovr_0_anh001(bufSize: Int32; pattern: IntPtr);
external 'opengl32.dll' name 'glGetnPolygonStippleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; pattern: array of Byte) :=
if (pattern<>nil) and (pattern.Length<>0) then
z_GetnPolygonStippleARB_ovr_0(bufSize, pattern[0]) else
z_GetnPolygonStippleARB_ovr_0_anh001(bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; var pattern: Byte) :=
z_GetnPolygonStippleARB_ovr_0(bufSize, pattern);
private static procedure z_GetnPolygonStippleARB_ovr_2(bufSize: Int32; pattern: IntPtr);
external 'opengl32.dll' name 'glGetnPolygonStippleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; pattern: IntPtr) :=
z_GetnPolygonStippleARB_ovr_2(bufSize, pattern);
private static procedure z_GetnColorTableARB_ovr_0(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr);
external 'opengl32.dll' name 'glGetnColorTableARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnColorTableARB(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr) :=
z_GetnColorTableARB_ovr_0(target, format, &type, bufSize, table);
private static procedure z_GetnConvolutionFilterARB_ovr_0(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr);
external 'opengl32.dll' name 'glGetnConvolutionFilterARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnConvolutionFilterARB(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr) :=
z_GetnConvolutionFilterARB_ovr_0(target, format, &type, bufSize, image);
private static procedure z_GetnSeparableFilterARB_ovr_0(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr);
external 'opengl32.dll' name 'glGetnSeparableFilterARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnSeparableFilterARB(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr) :=
z_GetnSeparableFilterARB_ovr_0(target, format, &type, rowBufSize, row, columnBufSize, column, span);
private static procedure z_GetnHistogramARB_ovr_0(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnHistogramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnHistogramARB(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr) :=
z_GetnHistogramARB_ovr_0(target, reset, format, &type, bufSize, values);
private static procedure z_GetnMinmaxARB_ovr_0(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetnMinmaxARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMinmaxARB(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr) :=
z_GetnMinmaxARB_ovr_0(target, reset, format, &type, bufSize, values);
end;
[PCUNotRestore]
glSampleLocationsARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferSampleLocationsfvARB_ovr_0(target: FramebufferTarget; start: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvARB';
private static procedure z_FramebufferSampleLocationsfvARB_ovr_0_anh00001(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_FramebufferSampleLocationsfvARB_ovr_0(target, start, count, v[0]) else
z_FramebufferSampleLocationsfvARB_ovr_0_anh00001(target, start, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; var v: single) :=
z_FramebufferSampleLocationsfvARB_ovr_0(target, start, count, v);
private static procedure z_FramebufferSampleLocationsfvARB_ovr_2(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr) :=
z_FramebufferSampleLocationsfvARB_ovr_2(target, start, count, v);
private static procedure z_NamedFramebufferSampleLocationsfvARB_ovr_0(framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvARB';
private static procedure z_NamedFramebufferSampleLocationsfvARB_ovr_0_anh00001(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_NamedFramebufferSampleLocationsfvARB_ovr_0(framebuffer, start, count, v[0]) else
z_NamedFramebufferSampleLocationsfvARB_ovr_0_anh00001(framebuffer, start, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; var v: single) :=
z_NamedFramebufferSampleLocationsfvARB_ovr_0(framebuffer, start, count, v);
private static procedure z_NamedFramebufferSampleLocationsfvARB_ovr_2(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr) :=
z_NamedFramebufferSampleLocationsfvARB_ovr_2(framebuffer, start, count, v);
private static procedure z_EvaluateDepthValuesARB_ovr_0;
external 'opengl32.dll' name 'glEvaluateDepthValuesARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvaluateDepthValuesARB :=
z_EvaluateDepthValuesARB_ovr_0;
end;
[PCUNotRestore]
glSampleShadingARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MinSampleShadingARB_ovr_0(value: single);
external 'opengl32.dll' name 'glMinSampleShadingARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinSampleShadingARB(value: single) :=
z_MinSampleShadingARB_ovr_0(value);
end;
[PCUNotRestore]
glSamplerObjectsARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenSamplers_ovr_0(count: Int32; var samplers: UInt32);
external 'opengl32.dll' name 'glGenSamplers';
private static procedure z_GenSamplers_ovr_0_anh001(count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glGenSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_GenSamplers_ovr_0(count, samplers[0]) else
z_GenSamplers_ovr_0_anh001(count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; var samplers: UInt32) :=
z_GenSamplers_ovr_0(count, samplers);
private static procedure z_GenSamplers_ovr_2(count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glGenSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: IntPtr) :=
z_GenSamplers_ovr_2(count, samplers);
private static procedure z_DeleteSamplers_ovr_0(count: Int32; var samplers: UInt32);
external 'opengl32.dll' name 'glDeleteSamplers';
private static procedure z_DeleteSamplers_ovr_0_anh001(count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glDeleteSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: array of UInt32) :=
if (samplers<>nil) and (samplers.Length<>0) then
z_DeleteSamplers_ovr_0(count, samplers[0]) else
z_DeleteSamplers_ovr_0_anh001(count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; var samplers: UInt32) :=
z_DeleteSamplers_ovr_0(count, samplers);
private static procedure z_DeleteSamplers_ovr_2(count: Int32; samplers: IntPtr);
external 'opengl32.dll' name 'glDeleteSamplers';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: IntPtr) :=
z_DeleteSamplers_ovr_2(count, samplers);
private static function z_IsSampler_ovr_0(sampler: SamplerName): boolean;
external 'opengl32.dll' name 'glIsSampler';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSampler(sampler: SamplerName): boolean :=
z_IsSampler_ovr_0(sampler);
private static procedure z_BindSampler_ovr_0(&unit: UInt32; sampler: SamplerName);
external 'opengl32.dll' name 'glBindSampler';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSampler(&unit: UInt32; sampler: SamplerName) :=
z_BindSampler_ovr_0(&unit, sampler);
private static procedure z_SamplerParameteri_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: Int32);
external 'opengl32.dll' name 'glSamplerParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteri(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: Int32) :=
z_SamplerParameteri_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameteriv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32);
external 'opengl32.dll' name 'glSamplerParameteriv';
private static procedure z_SamplerParameteriv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameteriv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameteriv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32) :=
z_SamplerParameteriv_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameteriv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameteriv_ovr_2(sampler, pname, param);
private static procedure z_SamplerParameterf_ovr_0(sampler: SamplerName; pname: OpenGL.SamplerParameterF; param: single);
external 'opengl32.dll' name 'glSamplerParameterf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterf(sampler: SamplerName; pname: OpenGL.SamplerParameterF; param: single) :=
z_SamplerParameterf_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameterfv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single);
external 'opengl32.dll' name 'glSamplerParameterfv';
private static procedure z_SamplerParameterfv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterfv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterfv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single) :=
z_SamplerParameterfv_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameterfv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: IntPtr) :=
z_SamplerParameterfv_ovr_2(sampler, pname, param);
private static procedure z_SamplerParameterIiv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32);
external 'opengl32.dll' name 'glSamplerParameterIiv';
private static procedure z_SamplerParameterIiv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterIiv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterIiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32) :=
z_SamplerParameterIiv_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameterIiv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameterIiv_ovr_2(sampler, pname, param);
private static procedure z_SamplerParameterIuiv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32);
external 'opengl32.dll' name 'glSamplerParameterIuiv';
private static procedure z_SamplerParameterIuiv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of UInt32) :=
if (param<>nil) and (param.Length<>0) then
z_SamplerParameterIuiv_ovr_0(sampler, pname, param[0]) else
z_SamplerParameterIuiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32) :=
z_SamplerParameterIuiv_ovr_0(sampler, pname, param);
private static procedure z_SamplerParameterIuiv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr);
external 'opengl32.dll' name 'glSamplerParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: IntPtr) :=
z_SamplerParameterIuiv_ovr_2(sampler, pname, param);
private static procedure z_GetSamplerParameteriv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetSamplerParameteriv';
private static procedure z_GetSamplerParameteriv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameteriv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: Int32) :=
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameteriv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameteriv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameteriv_ovr_2(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterIiv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetSamplerParameterIiv';
private static procedure z_GetSamplerParameterIiv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterIiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: Int32) :=
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterIiv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterIiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameterIiv_ovr_2(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterfv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterF; var ¶ms: single);
external 'opengl32.dll' name 'glGetSamplerParameterfv';
private static procedure z_GetSamplerParameterfv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterF; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterfv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; var ¶ms: single) :=
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterfv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterF; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; ¶ms: IntPtr) :=
z_GetSamplerParameterfv_ovr_2(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterIuiv_ovr_0(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetSamplerParameterIuiv';
private static procedure z_GetSamplerParameterIuiv_ovr_0_anh0001(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms[0]) else
z_GetSamplerParameterIuiv_ovr_0_anh0001(sampler, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var ¶ms: UInt32) :=
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms);
private static procedure z_GetSamplerParameterIuiv_ovr_2(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSamplerParameterIuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; ¶ms: IntPtr) :=
z_GetSamplerParameterIuiv_ovr_2(sampler, pname, ¶ms);
end;
[PCUNotRestore]
glSeparateShaderObjectsARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_UseProgramStages_ovr_0(pipeline: ProgramPipelineName; stages: UseProgramStageMask; &program: ProgramName);
external 'opengl32.dll' name 'glUseProgramStages';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgramStages(pipeline: ProgramPipelineName; stages: UseProgramStageMask; &program: ProgramName) :=
z_UseProgramStages_ovr_0(pipeline, stages, &program);
private static procedure z_ActiveShaderProgram_ovr_0(pipeline: ProgramPipelineName; &program: ProgramName);
external 'opengl32.dll' name 'glActiveShaderProgram';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveShaderProgram(pipeline: ProgramPipelineName; &program: ProgramName) :=
z_ActiveShaderProgram_ovr_0(pipeline, &program);
private static function z_CreateShaderProgramv_ovr_0(&type: ShaderType; count: Int32; var strings: IntPtr): ProgramName;
external 'opengl32.dll' name 'glCreateShaderProgramv';
private static function z_CreateShaderProgramv_ovr_0_anh0001(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName;
external 'opengl32.dll' name 'glCreateShaderProgramv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: array of string): ProgramName;
begin
var par_3_str_ptr := strings?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
Result := z_CreateShaderProgramv_ovr_0(&type, count, par_3_str_ptr[0]) else
Result := z_CreateShaderProgramv_ovr_0_anh0001(&type, count, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static function z_CreateShaderProgramv_ovr_1_anh0001(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName;
external 'opengl32.dll' name 'glCreateShaderProgramv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: array of IntPtr): ProgramName :=
if (strings<>nil) and (strings.Length<>0) then
z_CreateShaderProgramv_ovr_0(&type, count, strings[0]) else
z_CreateShaderProgramv_ovr_0_anh0001(&type, count, IntPtr.Zero);
private static function z_CreateShaderProgramv_ovr_2(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName;
external 'opengl32.dll' name 'glCreateShaderProgramv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: IntPtr): ProgramName :=
z_CreateShaderProgramv_ovr_2(&type, count, strings);
private static procedure z_BindProgramPipeline_ovr_0(pipeline: ProgramPipelineName);
external 'opengl32.dll' name 'glBindProgramPipeline';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramPipeline(pipeline: ProgramPipelineName) :=
z_BindProgramPipeline_ovr_0(pipeline);
private static procedure z_DeleteProgramPipelines_ovr_0(n: Int32; var pipelines: UInt32);
external 'opengl32.dll' name 'glDeleteProgramPipelines';
private static procedure z_DeleteProgramPipelines_ovr_0_anh001(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_DeleteProgramPipelines_ovr_0(n, pipelines[0]) else
z_DeleteProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_DeleteProgramPipelines_ovr_0(n, pipelines);
private static procedure z_DeleteProgramPipelines_ovr_2(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_DeleteProgramPipelines_ovr_2(n, pipelines);
private static procedure z_GenProgramPipelines_ovr_0(n: Int32; var pipelines: UInt32);
external 'opengl32.dll' name 'glGenProgramPipelines';
private static procedure z_GenProgramPipelines_ovr_0_anh001(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glGenProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: array of UInt32) :=
if (pipelines<>nil) and (pipelines.Length<>0) then
z_GenProgramPipelines_ovr_0(n, pipelines[0]) else
z_GenProgramPipelines_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; var pipelines: UInt32) :=
z_GenProgramPipelines_ovr_0(n, pipelines);
private static procedure z_GenProgramPipelines_ovr_2(n: Int32; pipelines: IntPtr);
external 'opengl32.dll' name 'glGenProgramPipelines';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: IntPtr) :=
z_GenProgramPipelines_ovr_2(n, pipelines);
private static function z_IsProgramPipeline_ovr_0(pipeline: ProgramPipelineName): boolean;
external 'opengl32.dll' name 'glIsProgramPipeline';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramPipeline(pipeline: ProgramPipelineName): boolean :=
z_IsProgramPipeline_ovr_0(pipeline);
private static procedure z_GetProgramPipelineiv_ovr_0(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramPipelineiv';
private static procedure z_GetProgramPipelineiv_ovr_0_anh0001(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramPipelineiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms[0]) else
z_GetProgramPipelineiv_ovr_0_anh0001(pipeline, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32) :=
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms);
private static procedure z_GetProgramPipelineiv_ovr_2(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramPipelineiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; ¶ms: IntPtr) :=
z_GetProgramPipelineiv_ovr_2(pipeline, pname, ¶ms);
private static procedure z_ProgramParameteri_ovr_0(&program: ProgramName; pname: ProgramParameterPName; value: Int32);
external 'opengl32.dll' name 'glProgramParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteri(&program: ProgramName; pname: ProgramParameterPName; value: Int32) :=
z_ProgramParameteri_ovr_0(&program, pname, value);
private static procedure z_ProgramUniform1i_ovr_0(&program: ProgramName; location: Int32; v0: Int32);
external 'opengl32.dll' name 'glProgramUniform1i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i(&program: ProgramName; location: Int32; v0: Int32) :=
z_ProgramUniform1i_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform1iv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform1iv';
private static procedure z_ProgramUniform1iv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform1iv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1iv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1iv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1f_ovr_0(&program: ProgramName; location: Int32; v0: single);
external 'opengl32.dll' name 'glProgramUniform1f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1f(&program: ProgramName; location: Int32; v0: single) :=
z_ProgramUniform1f_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform1fv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform1fv';
private static procedure z_ProgramUniform1fv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform1fv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1fv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1fv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1d_ovr_0(&program: ProgramName; location: Int32; v0: real);
external 'opengl32.dll' name 'glProgramUniform1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1d(&program: ProgramName; location: Int32; v0: real) :=
z_ProgramUniform1d_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform1dv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform1dv';
private static procedure z_ProgramUniform1dv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform1dv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1dv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1dv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1ui_ovr_0(&program: ProgramName; location: Int32; v0: UInt32);
external 'opengl32.dll' name 'glProgramUniform1ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui(&program: ProgramName; location: Int32; v0: UInt32) :=
z_ProgramUniform1ui_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform1uiv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform1uiv';
private static procedure z_ProgramUniform1uiv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform1uiv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1uiv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1uiv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2i_ovr_0(&program: ProgramName; location: Int32; v0: Int32; v1: Int32);
external 'opengl32.dll' name 'glProgramUniform2i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32) :=
z_ProgramUniform2i_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform2iv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform2iv';
private static procedure z_ProgramUniform2iv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform2iv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2iv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2iv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2f_ovr_0(&program: ProgramName; location: Int32; v0: single; v1: single);
external 'opengl32.dll' name 'glProgramUniform2f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2f(&program: ProgramName; location: Int32; v0: single; v1: single) :=
z_ProgramUniform2f_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform2fv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform2fv';
private static procedure z_ProgramUniform2fv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform2fv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2fv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2fv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2d_ovr_0(&program: ProgramName; location: Int32; v0: real; v1: real);
external 'opengl32.dll' name 'glProgramUniform2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2d(&program: ProgramName; location: Int32; v0: real; v1: real) :=
z_ProgramUniform2d_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform2dv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform2dv';
private static procedure z_ProgramUniform2dv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform2dv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2dv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2dv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2ui_ovr_0(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32);
external 'opengl32.dll' name 'glProgramUniform2ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32) :=
z_ProgramUniform2ui_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform2uiv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform2uiv';
private static procedure z_ProgramUniform2uiv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform2uiv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2uiv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2uiv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3i_ovr_0(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32);
external 'opengl32.dll' name 'glProgramUniform3i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32) :=
z_ProgramUniform3i_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform3iv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform3iv';
private static procedure z_ProgramUniform3iv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform3iv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3iv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3iv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3f_ovr_0(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single);
external 'opengl32.dll' name 'glProgramUniform3f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3f(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single) :=
z_ProgramUniform3f_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform3fv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform3fv';
private static procedure z_ProgramUniform3fv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform3fv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3fv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3fv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3d_ovr_0(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real);
external 'opengl32.dll' name 'glProgramUniform3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3d(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real) :=
z_ProgramUniform3d_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform3dv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform3dv';
private static procedure z_ProgramUniform3dv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform3dv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3dv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3dv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3ui_ovr_0(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32);
external 'opengl32.dll' name 'glProgramUniform3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32) :=
z_ProgramUniform3ui_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform3uiv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform3uiv';
private static procedure z_ProgramUniform3uiv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform3uiv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3uiv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3uiv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4i_ovr_0(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32);
external 'opengl32.dll' name 'glProgramUniform4i';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i(&program: ProgramName; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32) :=
z_ProgramUniform4i_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform4iv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform4iv';
private static procedure z_ProgramUniform4iv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4iv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4iv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform4iv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4iv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4iv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4iv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4f_ovr_0(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single; v3: single);
external 'opengl32.dll' name 'glProgramUniform4f';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4f(&program: ProgramName; location: Int32; v0: single; v1: single; v2: single; v3: single) :=
z_ProgramUniform4f_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform4fv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform4fv';
private static procedure z_ProgramUniform4fv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4fv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4fv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform4fv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4fv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4fv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4d_ovr_0(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real; v3: real);
external 'opengl32.dll' name 'glProgramUniform4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4d(&program: ProgramName; location: Int32; v0: real; v1: real; v2: real; v3: real) :=
z_ProgramUniform4d_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform4dv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform4dv';
private static procedure z_ProgramUniform4dv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4dv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4dv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform4dv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4dv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4dv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4ui_ovr_0(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32);
external 'opengl32.dll' name 'glProgramUniform4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui(&program: ProgramName; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32) :=
z_ProgramUniform4ui_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform4uiv_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform4uiv';
private static procedure z_ProgramUniform4uiv_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4uiv_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4uiv_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform4uiv_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4uiv_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4uiv_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniformMatrix2fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2fv';
private static procedure z_ProgramUniformMatrix2fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3fv';
private static procedure z_ProgramUniformMatrix3fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4fv';
private static procedure z_ProgramUniformMatrix4fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2dv';
private static procedure z_ProgramUniformMatrix2dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3dv';
private static procedure z_ProgramUniformMatrix3dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4dv';
private static procedure z_ProgramUniformMatrix4dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fv';
private static procedure z_ProgramUniformMatrix2x3fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fv';
private static procedure z_ProgramUniformMatrix3x2fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fv';
private static procedure z_ProgramUniformMatrix2x4fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fv';
private static procedure z_ProgramUniformMatrix4x2fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fv';
private static procedure z_ProgramUniformMatrix3x4fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3fv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fv';
private static procedure z_ProgramUniformMatrix4x3fv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3fv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3fv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3fv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dv';
private static procedure z_ProgramUniformMatrix2x3dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dv';
private static procedure z_ProgramUniformMatrix3x2dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dv';
private static procedure z_ProgramUniformMatrix2x4dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dv';
private static procedure z_ProgramUniformMatrix4x2dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dv';
private static procedure z_ProgramUniformMatrix3x4dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3dv_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dv';
private static procedure z_ProgramUniformMatrix4x3dv_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3dv_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3dv_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3dv_ovr_2(&program, location, count, transpose, value);
private static procedure z_ValidateProgramPipeline_ovr_0(pipeline: ProgramPipelineName);
external 'opengl32.dll' name 'glValidateProgramPipeline';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgramPipeline(pipeline: ProgramPipelineName) :=
z_ValidateProgramPipeline_ovr_0(pipeline);
private static procedure z_GetProgramPipelineInfoLog_ovr_0(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetProgramPipelineInfoLog';
private static procedure z_GetProgramPipelineInfoLog_ovr_0_anh00010(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetProgramPipelineInfoLog';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; length: array of Int32; infoLog: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length[0], infoLog) else
z_GetProgramPipelineInfoLog_ovr_0_anh00010(pipeline, bufSize, IntPtr.Zero, infoLog);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr) :=
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length, infoLog);
private static procedure z_GetProgramPipelineInfoLog_ovr_2(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetProgramPipelineInfoLog';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; length: IntPtr; infoLog: IntPtr) :=
z_GetProgramPipelineInfoLog_ovr_2(pipeline, bufSize, length, infoLog);
end;
[PCUNotRestore]
glShaderAtomicCountersARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetActiveAtomicCounterBufferiv_ovr_0(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveAtomicCounterBufferiv';
private static procedure z_GetActiveAtomicCounterBufferiv_ovr_0_anh00001(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveAtomicCounterBufferiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms[0]) else
z_GetActiveAtomicCounterBufferiv_ovr_0_anh00001(&program, bufferIndex, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32) :=
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms);
private static procedure z_GetActiveAtomicCounterBufferiv_ovr_2(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveAtomicCounterBufferiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: IntPtr) :=
z_GetActiveAtomicCounterBufferiv_ovr_2(&program, bufferIndex, pname, ¶ms);
end;
[PCUNotRestore]
glShaderImageLoadStoreARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindImageTexture_ovr_0(&unit: UInt32; texture: TextureName; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: InternalFormat);
external 'opengl32.dll' name 'glBindImageTexture';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTexture(&unit: UInt32; texture: TextureName; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: InternalFormat) :=
z_BindImageTexture_ovr_0(&unit, texture, level, layered, layer, access, format);
private static procedure z_MemoryBarrier_ovr_0(barriers: MemoryBarrierMask);
external 'opengl32.dll' name 'glMemoryBarrier';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrier(barriers: MemoryBarrierMask) :=
z_MemoryBarrier_ovr_0(barriers);
end;
[PCUNotRestore]
glShaderObjectsARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DeleteObjectARB_ovr_0(obj: GLhandleARB);
external 'opengl32.dll' name 'glDeleteObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteObjectARB(obj: GLhandleARB) :=
z_DeleteObjectARB_ovr_0(obj);
private static function z_GetHandleARB_ovr_0(pname: DummyEnum): GLhandleARB;
external 'opengl32.dll' name 'glGetHandleARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetHandleARB(pname: DummyEnum): GLhandleARB :=
z_GetHandleARB_ovr_0(pname);
private static procedure z_DetachObjectARB_ovr_0(containerObj: GLhandleARB; attachedObj: GLhandleARB);
external 'opengl32.dll' name 'glDetachObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetachObjectARB(containerObj: GLhandleARB; attachedObj: GLhandleARB) :=
z_DetachObjectARB_ovr_0(containerObj, attachedObj);
private static function z_CreateShaderObjectARB_ovr_0(_shaderType: ShaderType): GLhandleARB;
external 'opengl32.dll' name 'glCreateShaderObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderObjectARB(_shaderType: ShaderType): GLhandleARB :=
z_CreateShaderObjectARB_ovr_0(_shaderType);
private static procedure z_ShaderSourceARB_ovr_0(shaderObj: GLhandleARB; count: Int32; var _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_0_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_0_anh00001(shaderObj: GLhandleARB; count: Int32; var _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_0_anh00011(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of string; length: array of Int32);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_ShaderSourceARB_ovr_0(shaderObj, count, par_3_str_ptr[0], length[0]) else
z_ShaderSourceARB_ovr_0_anh00001(shaderObj, count, par_3_str_ptr[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_ShaderSourceARB_ovr_0_anh00010(shaderObj, count, IntPtr.Zero, length[0]) else
z_ShaderSourceARB_ovr_0_anh00011(shaderObj, count, IntPtr.Zero, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_ShaderSourceARB_ovr_1_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of string; var length: Int32);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_ShaderSourceARB_ovr_0(shaderObj, count, par_3_str_ptr[0], length) else
z_ShaderSourceARB_ovr_0_anh00010(shaderObj, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_ShaderSourceARB_ovr_2(shaderObj: GLhandleARB; count: Int32; var _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_2_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of string; length: IntPtr);
begin
var par_3_str_ptr := _string?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_ShaderSourceARB_ovr_2(shaderObj, count, par_3_str_ptr[0], length) else
z_ShaderSourceARB_ovr_2_anh00010(shaderObj, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_ShaderSourceARB_ovr_3_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_3_anh00011(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; length: array of Int32) :=
if (_string<>nil) and (_string.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_ShaderSourceARB_ovr_0(shaderObj, count, _string[0], length[0]) else
z_ShaderSourceARB_ovr_0_anh00001(shaderObj, count, _string[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_ShaderSourceARB_ovr_0_anh00010(shaderObj, count, IntPtr.Zero, length[0]) else
z_ShaderSourceARB_ovr_0_anh00011(shaderObj, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_ShaderSourceARB_ovr_4_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; var length: Int32) :=
if (_string<>nil) and (_string.Length<>0) then
z_ShaderSourceARB_ovr_0(shaderObj, count, _string[0], length) else
z_ShaderSourceARB_ovr_0_anh00010(shaderObj, count, IntPtr.Zero, length);
private static procedure z_ShaderSourceARB_ovr_5_anh00010(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; length: IntPtr) :=
if (_string<>nil) and (_string.Length<>0) then
z_ShaderSourceARB_ovr_2(shaderObj, count, _string[0], length) else
z_ShaderSourceARB_ovr_2_anh00010(shaderObj, count, IntPtr.Zero, length);
private static procedure z_ShaderSourceARB_ovr_6(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glShaderSourceARB';
private static procedure z_ShaderSourceARB_ovr_6_anh00001(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
z_ShaderSourceARB_ovr_6(shaderObj, count, _string, length[0]) else
z_ShaderSourceARB_ovr_6_anh00001(shaderObj, count, _string, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32) :=
z_ShaderSourceARB_ovr_6(shaderObj, count, _string, length);
private static procedure z_ShaderSourceARB_ovr_8(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr) :=
z_ShaderSourceARB_ovr_8(shaderObj, count, _string, length);
private static procedure z_CompileShaderARB_ovr_0(shaderObj: GLhandleARB);
external 'opengl32.dll' name 'glCompileShaderARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderARB(shaderObj: GLhandleARB) :=
z_CompileShaderARB_ovr_0(shaderObj);
private static function z_CreateProgramObjectARB_ovr_0: GLhandleARB;
external 'opengl32.dll' name 'glCreateProgramObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgramObjectARB: GLhandleARB :=
z_CreateProgramObjectARB_ovr_0;
private static procedure z_AttachObjectARB_ovr_0(containerObj: GLhandleARB; obj: GLhandleARB);
external 'opengl32.dll' name 'glAttachObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AttachObjectARB(containerObj: GLhandleARB; obj: GLhandleARB) :=
z_AttachObjectARB_ovr_0(containerObj, obj);
private static procedure z_LinkProgramARB_ovr_0(programObj: GLhandleARB);
external 'opengl32.dll' name 'glLinkProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LinkProgramARB(programObj: GLhandleARB) :=
z_LinkProgramARB_ovr_0(programObj);
private static procedure z_UseProgramObjectARB_ovr_0(programObj: GLhandleARB);
external 'opengl32.dll' name 'glUseProgramObjectARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgramObjectARB(programObj: GLhandleARB) :=
z_UseProgramObjectARB_ovr_0(programObj);
private static procedure z_ValidateProgramARB_ovr_0(programObj: GLhandleARB);
external 'opengl32.dll' name 'glValidateProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgramARB(programObj: GLhandleARB) :=
z_ValidateProgramARB_ovr_0(programObj);
private static procedure z_Uniform1fARB_ovr_0(location: Int32; v0: single);
external 'opengl32.dll' name 'glUniform1fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fARB(location: Int32; v0: single) :=
z_Uniform1fARB_ovr_0(location, v0);
private static procedure z_Uniform2fARB_ovr_0(location: Int32; v0: single; v1: single);
external 'opengl32.dll' name 'glUniform2fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fARB(location: Int32; v0: single; v1: single) :=
z_Uniform2fARB_ovr_0(location, v0, v1);
private static procedure z_Uniform3fARB_ovr_0(location: Int32; v0: single; v1: single; v2: single);
external 'opengl32.dll' name 'glUniform3fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fARB(location: Int32; v0: single; v1: single; v2: single) :=
z_Uniform3fARB_ovr_0(location, v0, v1, v2);
private static procedure z_Uniform4fARB_ovr_0(location: Int32; v0: single; v1: single; v2: single; v3: single);
external 'opengl32.dll' name 'glUniform4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fARB(location: Int32; v0: single; v1: single; v2: single; v3: single) :=
z_Uniform4fARB_ovr_0(location, v0, v1, v2, v3);
private static procedure z_Uniform1iARB_ovr_0(location: Int32; v0: Int32);
external 'opengl32.dll' name 'glUniform1iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iARB(location: Int32; v0: Int32) :=
z_Uniform1iARB_ovr_0(location, v0);
private static procedure z_Uniform2iARB_ovr_0(location: Int32; v0: Int32; v1: Int32);
external 'opengl32.dll' name 'glUniform2iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iARB(location: Int32; v0: Int32; v1: Int32) :=
z_Uniform2iARB_ovr_0(location, v0, v1);
private static procedure z_Uniform3iARB_ovr_0(location: Int32; v0: Int32; v1: Int32; v2: Int32);
external 'opengl32.dll' name 'glUniform3iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iARB(location: Int32; v0: Int32; v1: Int32; v2: Int32) :=
z_Uniform3iARB_ovr_0(location, v0, v1, v2);
private static procedure z_Uniform4iARB_ovr_0(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32);
external 'opengl32.dll' name 'glUniform4iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iARB(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32) :=
z_Uniform4iARB_ovr_0(location, v0, v1, v2, v3);
private static procedure z_Uniform1fvARB_ovr_0(location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glUniform1fvARB';
private static procedure z_Uniform1fvARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1fvARB_ovr_0(location, count, value[0]) else
z_Uniform1fvARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; var value: single) :=
z_Uniform1fvARB_ovr_0(location, count, value);
private static procedure z_Uniform1fvARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1fvARB_ovr_2(location, count, value);
private static procedure z_Uniform2fvARB_ovr_0(location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glUniform2fvARB';
private static procedure z_Uniform2fvARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2fvARB_ovr_0(location, count, value[0]) else
z_Uniform2fvARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; var value: single) :=
z_Uniform2fvARB_ovr_0(location, count, value);
private static procedure z_Uniform2fvARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2fvARB_ovr_2(location, count, value);
private static procedure z_Uniform3fvARB_ovr_0(location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glUniform3fvARB';
private static procedure z_Uniform3fvARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3fvARB_ovr_0(location, count, value[0]) else
z_Uniform3fvARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; var value: single) :=
z_Uniform3fvARB_ovr_0(location, count, value);
private static procedure z_Uniform3fvARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3fvARB_ovr_2(location, count, value);
private static procedure z_Uniform4fvARB_ovr_0(location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glUniform4fvARB';
private static procedure z_Uniform4fvARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4fvARB_ovr_0(location, count, value[0]) else
z_Uniform4fvARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; var value: single) :=
z_Uniform4fvARB_ovr_0(location, count, value);
private static procedure z_Uniform4fvARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4fvARB_ovr_2(location, count, value);
private static procedure z_Uniform1ivARB_ovr_0(location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glUniform1ivARB';
private static procedure z_Uniform1ivARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1ivARB_ovr_0(location, count, value[0]) else
z_Uniform1ivARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; var value: Int32) :=
z_Uniform1ivARB_ovr_0(location, count, value);
private static procedure z_Uniform1ivARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1ivARB_ovr_2(location, count, value);
private static procedure z_Uniform2ivARB_ovr_0(location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glUniform2ivARB';
private static procedure z_Uniform2ivARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2ivARB_ovr_0(location, count, value[0]) else
z_Uniform2ivARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; var value: Int32) :=
z_Uniform2ivARB_ovr_0(location, count, value);
private static procedure z_Uniform2ivARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2ivARB_ovr_2(location, count, value);
private static procedure z_Uniform3ivARB_ovr_0(location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glUniform3ivARB';
private static procedure z_Uniform3ivARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3ivARB_ovr_0(location, count, value[0]) else
z_Uniform3ivARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; var value: Int32) :=
z_Uniform3ivARB_ovr_0(location, count, value);
private static procedure z_Uniform3ivARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3ivARB_ovr_2(location, count, value);
private static procedure z_Uniform4ivARB_ovr_0(location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glUniform4ivARB';
private static procedure z_Uniform4ivARB_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4ivARB_ovr_0(location, count, value[0]) else
z_Uniform4ivARB_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; var value: Int32) :=
z_Uniform4ivARB_ovr_0(location, count, value);
private static procedure z_Uniform4ivARB_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4ivARB_ovr_2(location, count, value);
private static procedure z_UniformMatrix2fvARB_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glUniformMatrix2fvARB';
private static procedure z_UniformMatrix2fvARB_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix2fvARB_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix2fvARB_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix2fvARB_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix2fvARB_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix2fvARB_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix3fvARB_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glUniformMatrix3fvARB';
private static procedure z_UniformMatrix3fvARB_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix3fvARB_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix3fvARB_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix3fvARB_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix3fvARB_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix3fvARB_ovr_2(location, count, transpose, value);
private static procedure z_UniformMatrix4fvARB_ovr_0(location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glUniformMatrix4fvARB';
private static procedure z_UniformMatrix4fvARB_ovr_0_anh00001(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_UniformMatrix4fvARB_ovr_0(location, count, transpose, value[0]) else
z_UniformMatrix4fvARB_ovr_0_anh00001(location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_UniformMatrix4fvARB_ovr_0(location, count, transpose, value);
private static procedure z_UniformMatrix4fvARB_ovr_2(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glUniformMatrix4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_UniformMatrix4fvARB_ovr_2(location, count, transpose, value);
private static procedure z_GetObjectParameterfvARB_ovr_0(obj: GLhandleARB; pname: DummyEnum; var ¶ms: single);
external 'opengl32.dll' name 'glGetObjectParameterfvARB';
private static procedure z_GetObjectParameterfvARB_ovr_0_anh0001(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetObjectParameterfvARB_ovr_0(obj, pname, ¶ms[0]) else
z_GetObjectParameterfvARB_ovr_0_anh0001(obj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; var ¶ms: single) :=
z_GetObjectParameterfvARB_ovr_0(obj, pname, ¶ms);
private static procedure z_GetObjectParameterfvARB_ovr_2(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetObjectParameterfvARB_ovr_2(obj, pname, ¶ms);
private static procedure z_GetObjectParameterivARB_ovr_0(obj: GLhandleARB; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetObjectParameterivARB';
private static procedure z_GetObjectParameterivARB_ovr_0_anh0001(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetObjectParameterivARB_ovr_0(obj, pname, ¶ms[0]) else
z_GetObjectParameterivARB_ovr_0_anh0001(obj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; var ¶ms: Int32) :=
z_GetObjectParameterivARB_ovr_0(obj, pname, ¶ms);
private static procedure z_GetObjectParameterivARB_ovr_2(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectParameterivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetObjectParameterivARB_ovr_2(obj, pname, ¶ms);
private static procedure z_GetInfoLogARB_ovr_0(obj: GLhandleARB; maxLength: Int32; var length: Int32; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetInfoLogARB';
private static procedure z_GetInfoLogARB_ovr_0_anh00010(obj: GLhandleARB; maxLength: Int32; length: IntPtr; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetInfoLogARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; length: array of Int32; infoLog: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetInfoLogARB_ovr_0(obj, maxLength, length[0], infoLog) else
z_GetInfoLogARB_ovr_0_anh00010(obj, maxLength, IntPtr.Zero, infoLog);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; var length: Int32; infoLog: IntPtr) :=
z_GetInfoLogARB_ovr_0(obj, maxLength, length, infoLog);
private static procedure z_GetInfoLogARB_ovr_2(obj: GLhandleARB; maxLength: Int32; length: IntPtr; infoLog: IntPtr);
external 'opengl32.dll' name 'glGetInfoLogARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; length: IntPtr; infoLog: IntPtr) :=
z_GetInfoLogARB_ovr_2(obj, maxLength, length, infoLog);
private static procedure z_GetAttachedObjectsARB_ovr_0(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; var obj: GLhandleARB);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
private static procedure z_GetAttachedObjectsARB_ovr_0_anh00010(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
private static procedure z_GetAttachedObjectsARB_ovr_0_anh00001(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
private static procedure z_GetAttachedObjectsARB_ovr_0_anh00011(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; obj: array of GLhandleARB) :=
if (count<>nil) and (count.Length<>0) then
if (obj<>nil) and (obj.Length<>0) then
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count[0], obj[0]) else
z_GetAttachedObjectsARB_ovr_0_anh00001(containerObj, maxCount, count[0], IntPtr.Zero) else
if (obj<>nil) and (obj.Length<>0) then
z_GetAttachedObjectsARB_ovr_0_anh00010(containerObj, maxCount, IntPtr.Zero, obj[0]) else
z_GetAttachedObjectsARB_ovr_0_anh00011(containerObj, maxCount, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetAttachedObjectsARB_ovr_1_anh00010(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; var obj: GLhandleARB) :=
if (count<>nil) and (count.Length<>0) then
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count[0], obj) else
z_GetAttachedObjectsARB_ovr_0_anh00010(containerObj, maxCount, IntPtr.Zero, obj);
private static procedure z_GetAttachedObjectsARB_ovr_2(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
private static procedure z_GetAttachedObjectsARB_ovr_2_anh00010(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; obj: IntPtr) :=
if (count<>nil) and (count.Length<>0) then
z_GetAttachedObjectsARB_ovr_2(containerObj, maxCount, count[0], obj) else
z_GetAttachedObjectsARB_ovr_2_anh00010(containerObj, maxCount, IntPtr.Zero, obj);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: array of GLhandleARB) :=
if (obj<>nil) and (obj.Length<>0) then
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count, obj[0]) else
z_GetAttachedObjectsARB_ovr_0_anh00001(containerObj, maxCount, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; var obj: GLhandleARB) :=
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count, obj);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: IntPtr) :=
z_GetAttachedObjectsARB_ovr_2(containerObj, maxCount, count, obj);
private static procedure z_GetAttachedObjectsARB_ovr_6(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
private static procedure z_GetAttachedObjectsARB_ovr_6_anh00001(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: array of GLhandleARB) :=
if (obj<>nil) and (obj.Length<>0) then
z_GetAttachedObjectsARB_ovr_6(containerObj, maxCount, count, obj[0]) else
z_GetAttachedObjectsARB_ovr_6_anh00001(containerObj, maxCount, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB) :=
z_GetAttachedObjectsARB_ovr_6(containerObj, maxCount, count, obj);
private static procedure z_GetAttachedObjectsARB_ovr_8(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr);
external 'opengl32.dll' name 'glGetAttachedObjectsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr) :=
z_GetAttachedObjectsARB_ovr_8(containerObj, maxCount, count, obj);
private static function z_GetUniformLocationARB_ovr_0(programObj: GLhandleARB; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetUniformLocationARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformLocationARB(programObj: GLhandleARB; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetUniformLocationARB_ovr_0(programObj, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformLocationARB(programObj: GLhandleARB; name: IntPtr): Int32 :=
z_GetUniformLocationARB_ovr_0(programObj, name);
private static procedure z_GetActiveUniformARB_ovr_0(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00000110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_0_anh00001110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000010(programObj, index, maxLength, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000110(programObj, index, maxLength, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00001010(programObj, index, maxLength, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00001110(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveUniformARB_ovr_1_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_1_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_1_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type, name) else
z_GetActiveUniformARB_ovr_0_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type, name) else
z_GetActiveUniformARB_ovr_0_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveUniformARB_ovr_2(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_2_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_2_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_2_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length[0], size[0], &type, name) else
z_GetActiveUniformARB_ovr_2_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_2_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type, name) else
z_GetActiveUniformARB_ovr_2_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveUniformARB_ovr_3_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_3_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000010(programObj, index, maxLength, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00001010(programObj, index, maxLength, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveUniformARB_ovr_4_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveUniformARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_5_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveUniformARB_ovr_2_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_6(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_6_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_6_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_6_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length[0], size, &type[0], name) else
z_GetActiveUniformARB_ovr_6_anh00000010(programObj, index, maxLength, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_6_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type[0], name) else
z_GetActiveUniformARB_ovr_6_anh00001010(programObj, index, maxLength, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveUniformARB_ovr_7_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; var &type: UniformType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveUniformARB_ovr_6_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_8(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_8_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformARB_ovr_8(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveUniformARB_ovr_8_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size[0], &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000010(programObj, index, maxLength, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000110(programObj, index, maxLength, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveUniformARB_ovr_0_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveUniformARB_ovr_2_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveUniformARB_ovr_0_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveUniformARB_ovr_6_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniformARB_ovr_8(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_18(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_18_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_18_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_18_anh00000110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: array of UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size[0], &type[0], name) else
z_GetActiveUniformARB_ovr_18_anh00000010(programObj, index, maxLength, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_18_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type[0], name) else
z_GetActiveUniformARB_ovr_18_anh00000110(programObj, index, maxLength, length, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveUniformARB_ovr_19_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; var &type: UniformType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveUniformARB_ovr_18_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
private static procedure z_GetActiveUniformARB_ovr_20(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_20_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveUniformARB_ovr_20(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveUniformARB_ovr_20_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveUniformARB_ovr_18_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniformARB_ovr_20(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_24(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
private static procedure z_GetActiveUniformARB_ovr_24_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: array of UniformType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveUniformARB_ovr_24(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveUniformARB_ovr_24_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr) :=
z_GetActiveUniformARB_ovr_24(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveUniformARB_ovr_26(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveUniformARB_ovr_26(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetUniformfvARB_ovr_0(programObj: GLhandleARB; location: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetUniformfvARB';
private static procedure z_GetUniformfvARB_ovr_0_anh0001(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformfvARB_ovr_0(programObj, location, ¶ms[0]) else
z_GetUniformfvARB_ovr_0_anh0001(programObj, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; var ¶ms: single) :=
z_GetUniformfvARB_ovr_0(programObj, location, ¶ms);
private static procedure z_GetUniformfvARB_ovr_2(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr) :=
z_GetUniformfvARB_ovr_2(programObj, location, ¶ms);
private static procedure z_GetUniformivARB_ovr_0(programObj: GLhandleARB; location: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetUniformivARB';
private static procedure z_GetUniformivARB_ovr_0_anh0001(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformivARB_ovr_0(programObj, location, ¶ms[0]) else
z_GetUniformivARB_ovr_0_anh0001(programObj, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; var ¶ms: Int32) :=
z_GetUniformivARB_ovr_0(programObj, location, ¶ms);
private static procedure z_GetUniformivARB_ovr_2(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr) :=
z_GetUniformivARB_ovr_2(programObj, location, ¶ms);
private static procedure z_GetShaderSourceARB_ovr_0(obj: GLhandleARB; maxLength: Int32; var length: Int32; source: IntPtr);
external 'opengl32.dll' name 'glGetShaderSourceARB';
private static procedure z_GetShaderSourceARB_ovr_0_anh00010(obj: GLhandleARB; maxLength: Int32; length: IntPtr; source: IntPtr);
external 'opengl32.dll' name 'glGetShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; length: array of Int32; source: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetShaderSourceARB_ovr_0(obj, maxLength, length[0], source) else
z_GetShaderSourceARB_ovr_0_anh00010(obj, maxLength, IntPtr.Zero, source);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; var length: Int32; source: IntPtr) :=
z_GetShaderSourceARB_ovr_0(obj, maxLength, length, source);
private static procedure z_GetShaderSourceARB_ovr_2(obj: GLhandleARB; maxLength: Int32; length: IntPtr; source: IntPtr);
external 'opengl32.dll' name 'glGetShaderSourceARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; length: IntPtr; source: IntPtr) :=
z_GetShaderSourceARB_ovr_2(obj, maxLength, length, source);
end;
[PCUNotRestore]
glShaderStorageBufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ShaderStorageBlockBinding_ovr_0(&program: ProgramName; storageBlockIndex: UInt32; storageBlockBinding: UInt32);
external 'opengl32.dll' name 'glShaderStorageBlockBinding';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderStorageBlockBinding(&program: ProgramName; storageBlockIndex: UInt32; storageBlockBinding: UInt32) :=
z_ShaderStorageBlockBinding_ovr_0(&program, storageBlockIndex, storageBlockBinding);
end;
[PCUNotRestore]
glShaderSubroutineARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetSubroutineUniformLocation_ovr_0(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetSubroutineUniformLocation';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineUniformLocation(&program: ProgramName; _shadertype: ShaderType; name: string): Int32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetSubroutineUniformLocation_ovr_0(&program, _shadertype, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineUniformLocation(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): Int32 :=
z_GetSubroutineUniformLocation_ovr_0(&program, _shadertype, name);
private static function z_GetSubroutineIndex_ovr_0(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetSubroutineIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineIndex(&program: ProgramName; _shadertype: ShaderType; name: string): UInt32;
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetSubroutineIndex_ovr_0(&program, _shadertype, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetSubroutineIndex(&program: ProgramName; _shadertype: ShaderType; name: IntPtr): UInt32 :=
z_GetSubroutineIndex_ovr_0(&program, _shadertype, name);
private static procedure z_GetActiveSubroutineUniformiv_ovr_0(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformiv';
private static procedure z_GetActiveSubroutineUniformiv_ovr_0_anh000001(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values[0]) else
z_GetActiveSubroutineUniformiv_ovr_0_anh000001(&program, _shadertype, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32) :=
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values);
private static procedure z_GetActiveSubroutineUniformiv_ovr_2(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: IntPtr) :=
z_GetActiveSubroutineUniformiv_ovr_2(&program, _shadertype, index, pname, values);
private static procedure z_GetActiveSubroutineUniformName_ovr_0(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformName';
private static procedure z_GetActiveSubroutineUniformName_ovr_0_anh0000010(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length[0], name) else
z_GetActiveSubroutineUniformName_ovr_0_anh0000010(&program, _shadertype, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length, name);
private static procedure z_GetActiveSubroutineUniformName_ovr_2(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineUniformName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetActiveSubroutineUniformName_ovr_2(&program, _shadertype, index, bufSize, length, name);
private static procedure z_GetActiveSubroutineName_ovr_0(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineName';
private static procedure z_GetActiveSubroutineName_ovr_0_anh0000010(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: array of Int32; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length[0], name) else
z_GetActiveSubroutineName_ovr_0_anh0000010(&program, _shadertype, index, bufSize, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr) :=
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length, name);
private static procedure z_GetActiveSubroutineName_ovr_2(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveSubroutineName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; length: IntPtr; name: IntPtr) :=
z_GetActiveSubroutineName_ovr_2(&program, _shadertype, index, bufSize, length, name);
private static procedure z_UniformSubroutinesuiv_ovr_0(_shadertype: ShaderType; count: Int32; var indices: UInt32);
external 'opengl32.dll' name 'glUniformSubroutinesuiv';
private static procedure z_UniformSubroutinesuiv_ovr_0_anh0001(_shadertype: ShaderType; count: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glUniformSubroutinesuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; indices: array of UInt32) :=
if (indices<>nil) and (indices.Length<>0) then
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices[0]) else
z_UniformSubroutinesuiv_ovr_0_anh0001(_shadertype, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; var indices: UInt32) :=
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices);
private static procedure z_UniformSubroutinesuiv_ovr_2(_shadertype: ShaderType; count: Int32; indices: IntPtr);
external 'opengl32.dll' name 'glUniformSubroutinesuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; indices: IntPtr) :=
z_UniformSubroutinesuiv_ovr_2(_shadertype, count, indices);
private static procedure z_GetUniformSubroutineuiv_ovr_0(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetUniformSubroutineuiv';
private static procedure z_GetUniformSubroutineuiv_ovr_0_anh0001(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformSubroutineuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms[0]) else
z_GetUniformSubroutineuiv_ovr_0_anh0001(_shadertype, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32) :=
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms);
private static procedure z_GetUniformSubroutineuiv_ovr_2(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformSubroutineuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; ¶ms: IntPtr) :=
z_GetUniformSubroutineuiv_ovr_2(_shadertype, location, ¶ms);
private static procedure z_GetProgramStageiv_ovr_0(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32);
external 'opengl32.dll' name 'glGetProgramStageiv';
private static procedure z_GetProgramStageiv_ovr_0_anh00001(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr);
external 'opengl32.dll' name 'glGetProgramStageiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values[0]) else
z_GetProgramStageiv_ovr_0_anh00001(&program, _shadertype, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32) :=
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values);
private static procedure z_GetProgramStageiv_ovr_2(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr);
external 'opengl32.dll' name 'glGetProgramStageiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: IntPtr) :=
z_GetProgramStageiv_ovr_2(&program, _shadertype, pname, values);
end;
[PCUNotRestore]
glShadingLanguageIncludeARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_NamedStringARB_ovr_0(&type: DummyEnum; namelen: Int32; name: IntPtr; stringlen: Int32; _string: IntPtr);
external 'opengl32.dll' name 'glNamedStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedStringARB(&type: DummyEnum; namelen: Int32; name: string; stringlen: Int32; _string: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
var par_5_str_ptr := Marshal.StringToHGlobalAnsi(_string);
z_NamedStringARB_ovr_0(&type, namelen, par_3_str_ptr, stringlen, par_5_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
Marshal.FreeHGlobal(par_5_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedStringARB(&type: DummyEnum; namelen: Int32; name: string; stringlen: Int32; _string: IntPtr);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_NamedStringARB_ovr_0(&type, namelen, par_3_str_ptr, stringlen, _string);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedStringARB(&type: DummyEnum; namelen: Int32; name: IntPtr; stringlen: Int32; _string: string);
begin
var par_5_str_ptr := Marshal.StringToHGlobalAnsi(_string);
z_NamedStringARB_ovr_0(&type, namelen, name, stringlen, par_5_str_ptr);
Marshal.FreeHGlobal(par_5_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedStringARB(&type: DummyEnum; namelen: Int32; name: IntPtr; stringlen: Int32; _string: IntPtr) :=
z_NamedStringARB_ovr_0(&type, namelen, name, stringlen, _string);
private static procedure z_DeleteNamedStringARB_ovr_0(namelen: Int32; name: IntPtr);
external 'opengl32.dll' name 'glDeleteNamedStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamedStringARB(namelen: Int32; name: string);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_DeleteNamedStringARB_ovr_0(namelen, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamedStringARB(namelen: Int32; name: IntPtr) :=
z_DeleteNamedStringARB_ovr_0(namelen, name);
private static procedure z_CompileShaderIncludeARB_ovr_0(shader: UInt32; count: Int32; var path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_0_anh00010(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_0_anh00001(shader: UInt32; count: Int32; var path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_0_anh00011(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of string; length: array of Int32);
begin
var par_3_str_ptr := path?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_CompileShaderIncludeARB_ovr_0(shader, count, par_3_str_ptr[0], length[0]) else
z_CompileShaderIncludeARB_ovr_0_anh00001(shader, count, par_3_str_ptr[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_CompileShaderIncludeARB_ovr_0_anh00010(shader, count, IntPtr.Zero, length[0]) else
z_CompileShaderIncludeARB_ovr_0_anh00011(shader, count, IntPtr.Zero, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_CompileShaderIncludeARB_ovr_1_anh00010(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of string; var length: Int32);
begin
var par_3_str_ptr := path?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_CompileShaderIncludeARB_ovr_0(shader, count, par_3_str_ptr[0], length) else
z_CompileShaderIncludeARB_ovr_0_anh00010(shader, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_CompileShaderIncludeARB_ovr_2(shader: UInt32; count: Int32; var path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_2_anh00010(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of string; length: IntPtr);
begin
var par_3_str_ptr := path?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_CompileShaderIncludeARB_ovr_2(shader, count, par_3_str_ptr[0], length) else
z_CompileShaderIncludeARB_ovr_2_anh00010(shader, count, IntPtr.Zero, length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_CompileShaderIncludeARB_ovr_3_anh00010(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_3_anh00011(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; length: array of Int32) :=
if (path<>nil) and (path.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_CompileShaderIncludeARB_ovr_0(shader, count, path[0], length[0]) else
z_CompileShaderIncludeARB_ovr_0_anh00001(shader, count, path[0], IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
z_CompileShaderIncludeARB_ovr_0_anh00010(shader, count, IntPtr.Zero, length[0]) else
z_CompileShaderIncludeARB_ovr_0_anh00011(shader, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_CompileShaderIncludeARB_ovr_4_anh00010(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; var length: Int32) :=
if (path<>nil) and (path.Length<>0) then
z_CompileShaderIncludeARB_ovr_0(shader, count, path[0], length) else
z_CompileShaderIncludeARB_ovr_0_anh00010(shader, count, IntPtr.Zero, length);
private static procedure z_CompileShaderIncludeARB_ovr_5_anh00010(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; length: IntPtr) :=
if (path<>nil) and (path.Length<>0) then
z_CompileShaderIncludeARB_ovr_2(shader, count, path[0], length) else
z_CompileShaderIncludeARB_ovr_2_anh00010(shader, count, IntPtr.Zero, length);
private static procedure z_CompileShaderIncludeARB_ovr_6(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
private static procedure z_CompileShaderIncludeARB_ovr_6_anh00001(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; length: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
z_CompileShaderIncludeARB_ovr_6(shader, count, path, length[0]) else
z_CompileShaderIncludeARB_ovr_6_anh00001(shader, count, path, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; var length: Int32) :=
z_CompileShaderIncludeARB_ovr_6(shader, count, path, length);
private static procedure z_CompileShaderIncludeARB_ovr_8(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glCompileShaderIncludeARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr) :=
z_CompileShaderIncludeARB_ovr_8(shader, count, path, length);
private static function z_IsNamedStringARB_ovr_0(namelen: Int32; name: IntPtr): boolean;
external 'opengl32.dll' name 'glIsNamedStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNamedStringARB(namelen: Int32; name: string): boolean;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_IsNamedStringARB_ovr_0(namelen, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNamedStringARB(namelen: Int32; name: IntPtr): boolean :=
z_IsNamedStringARB_ovr_0(namelen, name);
private static procedure z_GetNamedStringARB_ovr_0(namelen: Int32; name: IntPtr; bufSize: Int32; var stringlen: Int32; string: IntPtr);
external 'opengl32.dll' name 'glGetNamedStringARB';
private static procedure z_GetNamedStringARB_ovr_0_anh000010(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: IntPtr; string: IntPtr);
external 'opengl32.dll' name 'glGetNamedStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: string; bufSize: Int32; stringlen: array of Int32; string: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
if (stringlen<>nil) and (stringlen.Length<>0) then
z_GetNamedStringARB_ovr_0(namelen, par_2_str_ptr, bufSize, stringlen[0], string) else
z_GetNamedStringARB_ovr_0_anh000010(namelen, par_2_str_ptr, bufSize, IntPtr.Zero, string);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: string; bufSize: Int32; var stringlen: Int32; string: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_GetNamedStringARB_ovr_0(namelen, par_2_str_ptr, bufSize, stringlen, string);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_GetNamedStringARB_ovr_2(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: IntPtr; string: IntPtr);
external 'opengl32.dll' name 'glGetNamedStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: string; bufSize: Int32; stringlen: IntPtr; string: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_GetNamedStringARB_ovr_2(namelen, par_2_str_ptr, bufSize, stringlen, string);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: array of Int32; string: IntPtr) :=
if (stringlen<>nil) and (stringlen.Length<>0) then
z_GetNamedStringARB_ovr_0(namelen, name, bufSize, stringlen[0], string) else
z_GetNamedStringARB_ovr_0_anh000010(namelen, name, bufSize, IntPtr.Zero, string);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: IntPtr; bufSize: Int32; var stringlen: Int32; string: IntPtr) :=
z_GetNamedStringARB_ovr_0(namelen, name, bufSize, stringlen, string);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: IntPtr; string: IntPtr) :=
z_GetNamedStringARB_ovr_2(namelen, name, bufSize, stringlen, string);
private static procedure z_GetNamedStringivARB_ovr_0(namelen: Int32; name: IntPtr; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedStringivARB';
private static procedure z_GetNamedStringivARB_ovr_0_anh00001(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedStringivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: string; pname: DummyEnum; ¶ms: array of Int32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedStringivARB_ovr_0(namelen, par_2_str_ptr, pname, ¶ms[0]) else
z_GetNamedStringivARB_ovr_0_anh00001(namelen, par_2_str_ptr, pname, IntPtr.Zero);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: string; pname: DummyEnum; var ¶ms: Int32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_GetNamedStringivARB_ovr_0(namelen, par_2_str_ptr, pname, ¶ms);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
private static procedure z_GetNamedStringivARB_ovr_2(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedStringivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: string; pname: DummyEnum; ¶ms: IntPtr);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_GetNamedStringivARB_ovr_2(namelen, par_2_str_ptr, pname, ¶ms);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedStringivARB_ovr_0(namelen, name, pname, ¶ms[0]) else
z_GetNamedStringivARB_ovr_0_anh00001(namelen, name, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: IntPtr; pname: DummyEnum; var ¶ms: Int32) :=
z_GetNamedStringivARB_ovr_0(namelen, name, pname, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetNamedStringivARB_ovr_2(namelen, name, pname, ¶ms);
end;
[PCUNotRestore]
glSparseBufferARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BufferPageCommitmentARB_ovr_0(target: DummyEnum; offset: IntPtr; size: IntPtr; commit: boolean);
external 'opengl32.dll' name 'glBufferPageCommitmentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferPageCommitmentARB(target: DummyEnum; offset: IntPtr; size: IntPtr; commit: boolean) :=
z_BufferPageCommitmentARB_ovr_0(target, offset, size, commit);
private static procedure z_NamedBufferPageCommitmentEXT_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean);
external 'opengl32.dll' name 'glNamedBufferPageCommitmentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferPageCommitmentEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean) :=
z_NamedBufferPageCommitmentEXT_ovr_0(buffer, offset, size, commit);
private static procedure z_NamedBufferPageCommitmentARB_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean);
external 'opengl32.dll' name 'glNamedBufferPageCommitmentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferPageCommitmentARB(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean) :=
z_NamedBufferPageCommitmentARB_ovr_0(buffer, offset, size, commit);
end;
[PCUNotRestore]
glSparseTextureARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexPageCommitmentARB_ovr_0(target: DummyEnum; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean);
external 'opengl32.dll' name 'glTexPageCommitmentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexPageCommitmentARB(target: DummyEnum; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean) :=
z_TexPageCommitmentARB_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
end;
[PCUNotRestore]
glSyncARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_FenceSync_ovr_0(condition: SyncCondition; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glFenceSync';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FenceSync(condition: SyncCondition; flags: DummyFlags): GLsync :=
z_FenceSync_ovr_0(condition, flags);
private static function z_IsSync_ovr_0(sync: GLsync): boolean;
external 'opengl32.dll' name 'glIsSync';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSync(sync: GLsync): boolean :=
z_IsSync_ovr_0(sync);
private static procedure z_DeleteSync_ovr_0(sync: GLsync);
external 'opengl32.dll' name 'glDeleteSync';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSync(sync: GLsync) :=
z_DeleteSync_ovr_0(sync);
private static function z_ClientWaitSync_ovr_0(sync: GLsync; flags: SyncObjectMask; timeout: UInt64): SyncStatus;
external 'opengl32.dll' name 'glClientWaitSync';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ClientWaitSync(sync: GLsync; flags: SyncObjectMask; timeout: UInt64): SyncStatus :=
z_ClientWaitSync_ovr_0(sync, flags, timeout);
private static procedure z_WaitSync_ovr_0(sync: GLsync; flags: DummyFlags; timeout: UInt64);
external 'opengl32.dll' name 'glWaitSync';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSync(sync: GLsync; flags: DummyFlags; timeout: UInt64) :=
z_WaitSync_ovr_0(sync, flags, timeout);
private static procedure z_GetInteger64v_ovr_0(pname: GetPName; var data: Int64);
external 'opengl32.dll' name 'glGetInteger64v';
private static procedure z_GetInteger64v_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetInteger64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: array of Int64) :=
if (data<>nil) and (data.Length<>0) then
z_GetInteger64v_ovr_0(pname, data[0]) else
z_GetInteger64v_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; var data: Int64) :=
z_GetInteger64v_ovr_0(pname, data);
private static procedure z_GetInteger64v_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetInteger64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: IntPtr) :=
z_GetInteger64v_ovr_2(pname, data);
private static procedure z_GetSynciv_ovr_0(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32);
external 'opengl32.dll' name 'glGetSynciv';
private static procedure z_GetSynciv_ovr_0_anh000010(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glGetSynciv';
private static procedure z_GetSynciv_ovr_0_anh000001(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
private static procedure z_GetSynciv_ovr_0_anh000011(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length[0], values[0]) else
z_GetSynciv_ovr_0_anh000001(sync, pname, count, length[0], IntPtr.Zero) else
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0_anh000010(sync, pname, count, IntPtr.Zero, values[0]) else
z_GetSynciv_ovr_0_anh000011(sync, pname, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetSynciv_ovr_1_anh000010(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glGetSynciv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; var values: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length[0], values) else
z_GetSynciv_ovr_0_anh000010(sync, pname, count, IntPtr.Zero, values);
private static procedure z_GetSynciv_ovr_2(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
private static procedure z_GetSynciv_ovr_2_anh000010(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetSynciv_ovr_2(sync, pname, count, length[0], values) else
z_GetSynciv_ovr_2_anh000010(sync, pname, count, IntPtr.Zero, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_0(sync, pname, count, length, values[0]) else
z_GetSynciv_ovr_0_anh000001(sync, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32) :=
z_GetSynciv_ovr_0(sync, pname, count, length, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr) :=
z_GetSynciv_ovr_2(sync, pname, count, length, values);
private static procedure z_GetSynciv_ovr_6(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glGetSynciv';
private static procedure z_GetSynciv_ovr_6_anh000001(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_GetSynciv_ovr_6(sync, pname, count, length, values[0]) else
z_GetSynciv_ovr_6_anh000001(sync, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32) :=
z_GetSynciv_ovr_6(sync, pname, count, length, values);
private static procedure z_GetSynciv_ovr_8(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glGetSynciv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; values: IntPtr) :=
z_GetSynciv_ovr_8(sync, pname, count, length, values);
end;
[PCUNotRestore]
glTessellationShaderARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PatchParameteri_ovr_0(pname: PatchParameterName; value: Int32);
external 'opengl32.dll' name 'glPatchParameteri';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameteri(pname: PatchParameterName; value: Int32) :=
z_PatchParameteri_ovr_0(pname, value);
private static procedure z_PatchParameterfv_ovr_0(pname: PatchParameterName; var values: single);
external 'opengl32.dll' name 'glPatchParameterfv';
private static procedure z_PatchParameterfv_ovr_0_anh001(pname: PatchParameterName; values: IntPtr);
external 'opengl32.dll' name 'glPatchParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: array of single) :=
if (values<>nil) and (values.Length<>0) then
z_PatchParameterfv_ovr_0(pname, values[0]) else
z_PatchParameterfv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; var values: single) :=
z_PatchParameterfv_ovr_0(pname, values);
private static procedure z_PatchParameterfv_ovr_2(pname: PatchParameterName; values: IntPtr);
external 'opengl32.dll' name 'glPatchParameterfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: IntPtr) :=
z_PatchParameterfv_ovr_2(pname, values);
end;
[PCUNotRestore]
glTextureBarrierARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureBarrier_ovr_0;
external 'opengl32.dll' name 'glTextureBarrier';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBarrier :=
z_TextureBarrier_ovr_0;
end;
[PCUNotRestore]
glTextureBufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexBufferARB_ovr_0(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
external 'opengl32.dll' name 'glTexBufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferARB(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32) :=
z_TexBufferARB_ovr_0(target, _internalformat, buffer);
end;
[PCUNotRestore]
glTextureBufferRangeARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexBufferRange_ovr_0(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glTexBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferRange(target: TextureTarget; _internalformat: InternalFormat; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_TexBufferRange_ovr_0(target, _internalformat, buffer, offset, size);
end;
[PCUNotRestore]
glTextureCompressionARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CompressedTexImage3DARB_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexImage3DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage3DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage3DARB_ovr_0(target, level, _internalformat, width, height, depth, border, imageSize, data);
private static procedure z_CompressedTexImage2DARB_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexImage2DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage2DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage2DARB_ovr_0(target, level, _internalformat, width, height, border, imageSize, data);
private static procedure z_CompressedTexImage1DARB_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexImage1DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage1DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr) :=
z_CompressedTexImage1DARB_ovr_0(target, level, _internalformat, width, border, imageSize, data);
private static procedure z_CompressedTexSubImage3DARB_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexSubImage3DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage3DARB(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage3DARB_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
private static procedure z_CompressedTexSubImage2DARB_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexSubImage2DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage2DARB(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage2DARB_ovr_0(target, level, xoffset, yoffset, width, height, format, imageSize, data);
private static procedure z_CompressedTexSubImage1DARB_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glCompressedTexSubImage1DARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage1DARB(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr) :=
z_CompressedTexSubImage1DARB_ovr_0(target, level, xoffset, width, format, imageSize, data);
private static procedure z_GetCompressedTexImageARB_ovr_0(target: TextureTarget; level: Int32; img: IntPtr);
external 'opengl32.dll' name 'glGetCompressedTexImageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTexImageARB(target: TextureTarget; level: Int32; img: IntPtr) :=
z_GetCompressedTexImageARB_ovr_0(target, level, img);
end;
[PCUNotRestore]
glTextureMultisampleARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexImage2DMultisample_ovr_0(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTexImage2DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage2DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TexImage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
private static procedure z_TexImage3DMultisample_ovr_0(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTexImage3DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TexImage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
private static procedure z_GetMultisamplefv_ovr_0(pname: GetMultisamplePNameNV; index: UInt32; var val: single);
external 'opengl32.dll' name 'glGetMultisamplefv';
private static procedure z_GetMultisamplefv_ovr_0_anh0001(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glGetMultisamplefv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; val: array of single) :=
if (val<>nil) and (val.Length<>0) then
z_GetMultisamplefv_ovr_0(pname, index, val[0]) else
z_GetMultisamplefv_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; var val: single) :=
z_GetMultisamplefv_ovr_0(pname, index, val);
private static procedure z_GetMultisamplefv_ovr_2(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glGetMultisamplefv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr) :=
z_GetMultisamplefv_ovr_2(pname, index, val);
private static procedure z_SampleMaski_ovr_0(maskNumber: UInt32; mask: DummyFlags);
external 'opengl32.dll' name 'glSampleMaski';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaski(maskNumber: UInt32; mask: DummyFlags) :=
z_SampleMaski_ovr_0(maskNumber, mask);
end;
[PCUNotRestore]
glTextureStorageARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexStorage1D_ovr_0(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32);
external 'opengl32.dll' name 'glTexStorage1D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage1D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32) :=
z_TexStorage1D_ovr_0(target, levels, _internalformat, width);
private static procedure z_TexStorage2D_ovr_0(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glTexStorage2D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage2D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_TexStorage2D_ovr_0(target, levels, _internalformat, width, height);
private static procedure z_TexStorage3D_ovr_0(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glTexStorage3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage3D(target: TextureTarget; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32) :=
z_TexStorage3D_ovr_0(target, levels, _internalformat, width, height, depth);
end;
[PCUNotRestore]
glTextureStorageMultisampleARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexStorage2DMultisample_ovr_0(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTexStorage2DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage2DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TexStorage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
private static procedure z_TexStorage3DMultisample_ovr_0(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTexStorage3DMultisample';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorage3DMultisample(target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TexStorage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
end;
[PCUNotRestore]
glTextureViewARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureView_ovr_0(texture: TextureName; target: TextureTarget; origtexture: TextureName; _internalformat: InternalFormat; minlevel: UInt32; numlevels: UInt32; minlayer: UInt32; numlayers: UInt32);
external 'opengl32.dll' name 'glTextureView';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureView(texture: TextureName; target: TextureTarget; origtexture: TextureName; _internalformat: InternalFormat; minlevel: UInt32; numlevels: UInt32; minlayer: UInt32; numlayers: UInt32) :=
z_TextureView_ovr_0(texture, target, origtexture, _internalformat, minlevel, numlevels, minlayer, numlayers);
end;
[PCUNotRestore]
glTimerQueryARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_QueryCounter_ovr_0(id: QueryName; target: QueryCounterTarget);
external 'opengl32.dll' name 'glQueryCounter';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryCounter(id: QueryName; target: QueryCounterTarget) :=
z_QueryCounter_ovr_0(id, target);
private static procedure z_GetQueryObjecti64v_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetQueryObjecti64v';
private static procedure z_GetQueryObjecti64v_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjecti64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjecti64v_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64) :=
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjecti64v_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjecti64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjecti64v_ovr_2(id, pname, ¶ms);
private static procedure z_GetQueryObjectui64v_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetQueryObjectui64v';
private static procedure z_GetQueryObjectui64v_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectui64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectui64v_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64) :=
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjectui64v_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectui64v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectui64v_ovr_2(id, pname, ¶ms);
end;
[PCUNotRestore]
glTransformFeedback2ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindTransformFeedback_ovr_0(target: BindTransformFeedbackTarget; id: TransformFeedbackName);
external 'opengl32.dll' name 'glBindTransformFeedback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedback(target: BindTransformFeedbackTarget; id: TransformFeedbackName) :=
z_BindTransformFeedback_ovr_0(target, id);
private static procedure z_DeleteTransformFeedbacks_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glDeleteTransformFeedbacks';
private static procedure z_DeleteTransformFeedbacks_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteTransformFeedbacks_ovr_0(n, ids[0]) else
z_DeleteTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_DeleteTransformFeedbacks_ovr_0(n, ids);
private static procedure z_DeleteTransformFeedbacks_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_DeleteTransformFeedbacks_ovr_2(n, ids);
private static procedure z_GenTransformFeedbacks_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glGenTransformFeedbacks';
private static procedure z_GenTransformFeedbacks_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenTransformFeedbacks_ovr_0(n, ids[0]) else
z_GenTransformFeedbacks_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; var ids: UInt32) :=
z_GenTransformFeedbacks_ovr_0(n, ids);
private static procedure z_GenTransformFeedbacks_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenTransformFeedbacks';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: IntPtr) :=
z_GenTransformFeedbacks_ovr_2(n, ids);
private static function z_IsTransformFeedback_ovr_0(id: TransformFeedbackName): boolean;
external 'opengl32.dll' name 'glIsTransformFeedback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTransformFeedback(id: TransformFeedbackName): boolean :=
z_IsTransformFeedback_ovr_0(id);
private static procedure z_PauseTransformFeedback_ovr_0;
external 'opengl32.dll' name 'glPauseTransformFeedback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PauseTransformFeedback :=
z_PauseTransformFeedback_ovr_0;
private static procedure z_ResumeTransformFeedback_ovr_0;
external 'opengl32.dll' name 'glResumeTransformFeedback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResumeTransformFeedback :=
z_ResumeTransformFeedback_ovr_0;
private static procedure z_DrawTransformFeedback_ovr_0(mode: PrimitiveType; id: TransformFeedbackName);
external 'opengl32.dll' name 'glDrawTransformFeedback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedback(mode: PrimitiveType; id: TransformFeedbackName) :=
z_DrawTransformFeedback_ovr_0(mode, id);
end;
[PCUNotRestore]
glTransformFeedback3ARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawTransformFeedbackStream_ovr_0(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32);
external 'opengl32.dll' name 'glDrawTransformFeedbackStream';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackStream(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32) :=
z_DrawTransformFeedbackStream_ovr_0(mode, id, stream);
private static procedure z_BeginQueryIndexed_ovr_0(target: QueryTarget; index: UInt32; id: QueryName);
external 'opengl32.dll' name 'glBeginQueryIndexed';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQueryIndexed(target: QueryTarget; index: UInt32; id: QueryName) :=
z_BeginQueryIndexed_ovr_0(target, index, id);
private static procedure z_EndQueryIndexed_ovr_0(target: QueryTarget; index: UInt32);
external 'opengl32.dll' name 'glEndQueryIndexed';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQueryIndexed(target: QueryTarget; index: UInt32) :=
z_EndQueryIndexed_ovr_0(target, index);
private static procedure z_GetQueryIndexediv_ovr_0(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetQueryIndexediv';
private static procedure z_GetQueryIndexediv_ovr_0_anh00001(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryIndexediv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms[0]) else
z_GetQueryIndexediv_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32) :=
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms);
private static procedure z_GetQueryIndexediv_ovr_2(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryIndexediv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: IntPtr) :=
z_GetQueryIndexediv_ovr_2(target, index, pname, ¶ms);
end;
[PCUNotRestore]
glTransformFeedbackInstancedARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawTransformFeedbackInstanced_ovr_0(mode: PrimitiveType; id: TransformFeedbackName; instancecount: Int32);
external 'opengl32.dll' name 'glDrawTransformFeedbackInstanced';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackInstanced(mode: PrimitiveType; id: TransformFeedbackName; instancecount: Int32) :=
z_DrawTransformFeedbackInstanced_ovr_0(mode, id, instancecount);
private static procedure z_DrawTransformFeedbackStreamInstanced_ovr_0(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32; instancecount: Int32);
external 'opengl32.dll' name 'glDrawTransformFeedbackStreamInstanced';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackStreamInstanced(mode: PrimitiveType; id: TransformFeedbackName; stream: UInt32; instancecount: Int32) :=
z_DrawTransformFeedbackStreamInstanced_ovr_0(mode, id, stream, instancecount);
end;
[PCUNotRestore]
glTransposeMatrixARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_LoadTransposeMatrixfARB_ovr_0(var m: single);
external 'opengl32.dll' name 'glLoadTransposeMatrixfARB';
private static procedure z_LoadTransposeMatrixfARB_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixfARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_LoadTransposeMatrixfARB_ovr_0(m[0]) else
z_LoadTransposeMatrixfARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(var m: single) :=
z_LoadTransposeMatrixfARB_ovr_0(m);
private static procedure z_LoadTransposeMatrixfARB_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixfARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(m: IntPtr) :=
z_LoadTransposeMatrixfARB_ovr_2(m);
private static procedure z_LoadTransposeMatrixdARB_ovr_0(var m: real);
external 'opengl32.dll' name 'glLoadTransposeMatrixdARB';
private static procedure z_LoadTransposeMatrixdARB_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixdARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_LoadTransposeMatrixdARB_ovr_0(m[0]) else
z_LoadTransposeMatrixdARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(var m: real) :=
z_LoadTransposeMatrixdARB_ovr_0(m);
private static procedure z_LoadTransposeMatrixdARB_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixdARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(m: IntPtr) :=
z_LoadTransposeMatrixdARB_ovr_2(m);
private static procedure z_MultTransposeMatrixfARB_ovr_0(var m: single);
external 'opengl32.dll' name 'glMultTransposeMatrixfARB';
private static procedure z_MultTransposeMatrixfARB_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixfARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MultTransposeMatrixfARB_ovr_0(m[0]) else
z_MultTransposeMatrixfARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(var m: single) :=
z_MultTransposeMatrixfARB_ovr_0(m);
private static procedure z_MultTransposeMatrixfARB_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixfARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(m: IntPtr) :=
z_MultTransposeMatrixfARB_ovr_2(m);
private static procedure z_MultTransposeMatrixdARB_ovr_0(var m: real);
external 'opengl32.dll' name 'glMultTransposeMatrixdARB';
private static procedure z_MultTransposeMatrixdARB_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixdARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MultTransposeMatrixdARB_ovr_0(m[0]) else
z_MultTransposeMatrixdARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(var m: real) :=
z_MultTransposeMatrixdARB_ovr_0(m);
private static procedure z_MultTransposeMatrixdARB_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixdARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(m: IntPtr) :=
z_MultTransposeMatrixdARB_ovr_2(m);
end;
[PCUNotRestore]
glUniformBufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetUniformIndices_ovr_0(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_0_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_0_anh00001(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_0_anh00011(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; uniformIndices: array of UInt32);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00001(&program, uniformCount, par_3_str_ptr[0], IntPtr.Zero) else
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00011(&program, uniformCount, IntPtr.Zero, IntPtr.Zero);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_GetUniformIndices_ovr_1_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; var uniformIndices: UInt32);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices) else
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_GetUniformIndices_ovr_2(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_2_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of string; uniformIndices: IntPtr);
begin
var par_3_str_ptr := uniformNames?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_GetUniformIndices_ovr_2(&program, uniformCount, par_3_str_ptr[0], uniformIndices) else
z_GetUniformIndices_ovr_2_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_GetUniformIndices_ovr_3_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_3_anh00011(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: array of UInt32) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00001(&program, uniformCount, uniformNames[0], IntPtr.Zero) else
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices[0]) else
z_GetUniformIndices_ovr_0_anh00011(&program, uniformCount, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetUniformIndices_ovr_4_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; var uniformIndices: UInt32) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices) else
z_GetUniformIndices_ovr_0_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
private static procedure z_GetUniformIndices_ovr_5_anh00010(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: IntPtr) :=
if (uniformNames<>nil) and (uniformNames.Length<>0) then
z_GetUniformIndices_ovr_2(&program, uniformCount, uniformNames[0], uniformIndices) else
z_GetUniformIndices_ovr_2_anh00010(&program, uniformCount, IntPtr.Zero, uniformIndices);
private static procedure z_GetUniformIndices_ovr_6(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
external 'opengl32.dll' name 'glGetUniformIndices';
private static procedure z_GetUniformIndices_ovr_6_anh00001(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: array of UInt32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices[0]) else
z_GetUniformIndices_ovr_6_anh00001(&program, uniformCount, uniformNames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32) :=
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices);
private static procedure z_GetUniformIndices_ovr_8(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr);
external 'opengl32.dll' name 'glGetUniformIndices';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; uniformIndices: IntPtr) :=
z_GetUniformIndices_ovr_8(&program, uniformCount, uniformNames, uniformIndices);
private static procedure z_GetActiveUniformsiv_ovr_0(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
private static procedure z_GetActiveUniformsiv_ovr_0_anh000100(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
private static procedure z_GetActiveUniformsiv_ovr_0_anh000001(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
private static procedure z_GetActiveUniformsiv_ovr_0_anh000101(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; ¶ms: array of Int32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000001(&program, uniformCount, uniformIndices[0], pname, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000101(&program, uniformCount, IntPtr.Zero, pname, IntPtr.Zero);
private static procedure z_GetActiveUniformsiv_ovr_1_anh000100(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; var ¶ms: Int32) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms) else
z_GetActiveUniformsiv_ovr_0_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms);
private static procedure z_GetActiveUniformsiv_ovr_2(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
private static procedure z_GetActiveUniformsiv_ovr_2_anh000100(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; ¶ms: IntPtr) :=
if (uniformIndices<>nil) and (uniformIndices.Length<>0) then
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices[0], pname, ¶ms) else
z_GetActiveUniformsiv_ovr_2_anh000100(&program, uniformCount, IntPtr.Zero, pname, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_0_anh000001(&program, uniformCount, uniformIndices, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32) :=
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr) :=
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices, pname, ¶ms);
private static procedure z_GetActiveUniformsiv_ovr_6(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
private static procedure z_GetActiveUniformsiv_ovr_6_anh000001(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms[0]) else
z_GetActiveUniformsiv_ovr_6_anh000001(&program, uniformCount, uniformIndices, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32) :=
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms);
private static procedure z_GetActiveUniformsiv_ovr_8(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformsiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; ¶ms: IntPtr) :=
z_GetActiveUniformsiv_ovr_8(&program, uniformCount, uniformIndices, pname, ¶ms);
private static procedure z_GetActiveUniformName_ovr_0(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformName';
private static procedure z_GetActiveUniformName_ovr_0_anh000010(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: array of Int32; uniformName: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length[0], uniformName) else
z_GetActiveUniformName_ovr_0_anh000010(&program, uniformIndex, bufSize, IntPtr.Zero, uniformName);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr) :=
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length, uniformName);
private static procedure z_GetActiveUniformName_ovr_2(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: IntPtr; uniformName: IntPtr) :=
z_GetActiveUniformName_ovr_2(&program, uniformIndex, bufSize, length, uniformName);
private static function z_GetUniformBlockIndex_ovr_0(&program: ProgramName; uniformBlockName: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetUniformBlockIndex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBlockIndex(&program: ProgramName; uniformBlockName: string): UInt32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(uniformBlockName);
Result := z_GetUniformBlockIndex_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBlockIndex(&program: ProgramName; uniformBlockName: IntPtr): UInt32 :=
z_GetUniformBlockIndex_ovr_0(&program, uniformBlockName);
private static procedure z_GetActiveUniformBlockiv_ovr_0(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetActiveUniformBlockiv';
private static procedure z_GetActiveUniformBlockiv_ovr_0_anh00001(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformBlockiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms[0]) else
z_GetActiveUniformBlockiv_ovr_0_anh00001(&program, uniformBlockIndex, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32) :=
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms);
private static procedure z_GetActiveUniformBlockiv_ovr_2(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformBlockiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: IntPtr) :=
z_GetActiveUniformBlockiv_ovr_2(&program, uniformBlockIndex, pname, ¶ms);
private static procedure z_GetActiveUniformBlockName_ovr_0(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformBlockName';
private static procedure z_GetActiveUniformBlockName_ovr_0_anh000010(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformBlockName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: array of Int32; uniformBlockName: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length[0], uniformBlockName) else
z_GetActiveUniformBlockName_ovr_0_anh000010(&program, uniformBlockIndex, bufSize, IntPtr.Zero, uniformBlockName);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr) :=
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
private static procedure z_GetActiveUniformBlockName_ovr_2(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr);
external 'opengl32.dll' name 'glGetActiveUniformBlockName';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: IntPtr; uniformBlockName: IntPtr) :=
z_GetActiveUniformBlockName_ovr_2(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
private static procedure z_UniformBlockBinding_ovr_0(&program: ProgramName; uniformBlockIndex: UInt32; uniformBlockBinding: UInt32);
external 'opengl32.dll' name 'glUniformBlockBinding';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformBlockBinding(&program: ProgramName; uniformBlockIndex: UInt32; uniformBlockBinding: UInt32) :=
z_UniformBlockBinding_ovr_0(&program, uniformBlockIndex, uniformBlockBinding);
private static procedure z_BindBufferRange_ovr_0(target: BufferTargetARB; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glBindBufferRange';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTargetARB; index: UInt32; buffer: BufferName; offset: IntPtr; size: IntPtr) :=
z_BindBufferRange_ovr_0(target, index, buffer, offset, size);
private static procedure z_BindBufferBase_ovr_0(target: BufferTargetARB; index: UInt32; buffer: BufferName);
external 'opengl32.dll' name 'glBindBufferBase';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTargetARB; index: UInt32; buffer: BufferName) :=
z_BindBufferBase_ovr_0(target, index, buffer);
private static procedure z_GetIntegeri_v_ovr_0(target: DummyEnum; index: UInt32; var data: Int32);
external 'opengl32.dll' name 'glGetIntegeri_v';
private static procedure z_GetIntegeri_v_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegeri_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetIntegeri_v_ovr_0(target, index, data[0]) else
z_GetIntegeri_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; var data: Int32) :=
z_GetIntegeri_v_ovr_0(target, index, data);
private static procedure z_GetIntegeri_v_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegeri_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetIntegeri_v_ovr_2(target, index, data);
end;
[PCUNotRestore]
glVertexArrayObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindVertexArray_ovr_0(&array: VertexArrayName);
external 'opengl32.dll' name 'glBindVertexArray';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexArray(&array: VertexArrayName) :=
z_BindVertexArray_ovr_0(&array);
private static procedure z_DeleteVertexArrays_ovr_0(n: Int32; var arrays: UInt32);
external 'opengl32.dll' name 'glDeleteVertexArrays';
private static procedure z_DeleteVertexArrays_ovr_0_anh001(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glDeleteVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_DeleteVertexArrays_ovr_0(n, arrays[0]) else
z_DeleteVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; var arrays: UInt32) :=
z_DeleteVertexArrays_ovr_0(n, arrays);
private static procedure z_DeleteVertexArrays_ovr_2(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glDeleteVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: IntPtr) :=
z_DeleteVertexArrays_ovr_2(n, arrays);
private static procedure z_GenVertexArrays_ovr_0(n: Int32; var arrays: UInt32);
external 'opengl32.dll' name 'glGenVertexArrays';
private static procedure z_GenVertexArrays_ovr_0_anh001(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glGenVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: array of UInt32) :=
if (arrays<>nil) and (arrays.Length<>0) then
z_GenVertexArrays_ovr_0(n, arrays[0]) else
z_GenVertexArrays_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; var arrays: UInt32) :=
z_GenVertexArrays_ovr_0(n, arrays);
private static procedure z_GenVertexArrays_ovr_2(n: Int32; arrays: IntPtr);
external 'opengl32.dll' name 'glGenVertexArrays';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: IntPtr) :=
z_GenVertexArrays_ovr_2(n, arrays);
private static function z_IsVertexArray_ovr_0(&array: VertexArrayName): boolean;
external 'opengl32.dll' name 'glIsVertexArray';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexArray(&array: VertexArrayName): boolean :=
z_IsVertexArray_ovr_0(&array);
end;
[PCUNotRestore]
glVertexAttrib64bitARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribL1d_ovr_0(index: UInt32; x: real);
external 'opengl32.dll' name 'glVertexAttribL1d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1d(index: UInt32; x: real) :=
z_VertexAttribL1d_ovr_0(index, x);
private static procedure z_VertexAttribL2d_ovr_0(index: UInt32; x: real; y: real);
external 'opengl32.dll' name 'glVertexAttribL2d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2d(index: UInt32; x: real; y: real) :=
z_VertexAttribL2d_ovr_0(index, x, y);
private static procedure z_VertexAttribL3d_ovr_0(index: UInt32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexAttribL3d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3d(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttribL3d_ovr_0(index, x, y, z);
private static procedure z_VertexAttribL4d_ovr_0(index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexAttribL4d';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4d(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttribL4d_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribL1dv_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL1dv';
private static procedure z_VertexAttribL1dv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1dv_ovr_0(index, v[0]) else
z_VertexAttribL1dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; var v: real) :=
z_VertexAttribL1dv_ovr_0(index, v);
private static procedure z_VertexAttribL1dv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL1dv_ovr_2(index, v);
private static procedure z_VertexAttribL2dv_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL2dv';
private static procedure z_VertexAttribL2dv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL2dv_ovr_0(index, v[0]) else
z_VertexAttribL2dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; var v: real) :=
z_VertexAttribL2dv_ovr_0(index, v);
private static procedure z_VertexAttribL2dv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL2dv_ovr_2(index, v);
private static procedure z_VertexAttribL3dv_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL3dv';
private static procedure z_VertexAttribL3dv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL3dv_ovr_0(index, v[0]) else
z_VertexAttribL3dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; var v: real) :=
z_VertexAttribL3dv_ovr_0(index, v);
private static procedure z_VertexAttribL3dv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL3dv_ovr_2(index, v);
private static procedure z_VertexAttribL4dv_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL4dv';
private static procedure z_VertexAttribL4dv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL4dv_ovr_0(index, v[0]) else
z_VertexAttribL4dv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; var v: real) :=
z_VertexAttribL4dv_ovr_0(index, v);
private static procedure z_VertexAttribL4dv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4dv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: IntPtr) :=
z_VertexAttribL4dv_ovr_2(index, v);
private static procedure z_VertexAttribLPointer_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribLPointer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLPointer(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexAttribLPointer_ovr_0(index, size, &type, stride, pointer);
private static procedure z_GetVertexAttribLdv_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: real);
external 'opengl32.dll' name 'glGetVertexAttribLdv';
private static procedure z_GetVertexAttribLdv_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLdv_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; var ¶ms: real) :=
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribLdv_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLdv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLdv_ovr_2(index, pname, ¶ms);
end;
[PCUNotRestore]
glVertexAttribBindingARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindVertexBuffer_ovr_0(bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32);
external 'opengl32.dll' name 'glBindVertexBuffer';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffer(bindingindex: UInt32; buffer: BufferName; offset: IntPtr; stride: Int32) :=
z_BindVertexBuffer_ovr_0(bindingindex, buffer, offset, stride);
private static procedure z_VertexAttribFormat_ovr_0(attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexAttribFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribFormat(attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32) :=
z_VertexAttribFormat_ovr_0(attribindex, size, &type, normalized, relativeoffset);
private static procedure z_VertexAttribIFormat_ovr_0(attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexAttribIFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIFormat(attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32) :=
z_VertexAttribIFormat_ovr_0(attribindex, size, &type, relativeoffset);
private static procedure z_VertexAttribLFormat_ovr_0(attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexAttribLFormat';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLFormat(attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32) :=
z_VertexAttribLFormat_ovr_0(attribindex, size, &type, relativeoffset);
private static procedure z_VertexAttribBinding_ovr_0(attribindex: UInt32; bindingindex: UInt32);
external 'opengl32.dll' name 'glVertexAttribBinding';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribBinding(attribindex: UInt32; bindingindex: UInt32) :=
z_VertexAttribBinding_ovr_0(attribindex, bindingindex);
private static procedure z_VertexBindingDivisor_ovr_0(bindingindex: UInt32; divisor: UInt32);
external 'opengl32.dll' name 'glVertexBindingDivisor';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBindingDivisor(bindingindex: UInt32; divisor: UInt32) :=
z_VertexBindingDivisor_ovr_0(bindingindex, divisor);
end;
[PCUNotRestore]
glVertexBlendARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_WeightbvARB_ovr_0(size: Int32; var weights: SByte);
external 'opengl32.dll' name 'glWeightbvARB';
private static procedure z_WeightbvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; weights: array of SByte) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightbvARB_ovr_0(size, weights[0]) else
z_WeightbvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; var weights: SByte) :=
z_WeightbvARB_ovr_0(size, weights);
private static procedure z_WeightbvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; weights: IntPtr) :=
z_WeightbvARB_ovr_2(size, weights);
private static procedure z_WeightsvARB_ovr_0(size: Int32; var weights: Int16);
external 'opengl32.dll' name 'glWeightsvARB';
private static procedure z_WeightsvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; weights: array of Int16) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightsvARB_ovr_0(size, weights[0]) else
z_WeightsvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; var weights: Int16) :=
z_WeightsvARB_ovr_0(size, weights);
private static procedure z_WeightsvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; weights: IntPtr) :=
z_WeightsvARB_ovr_2(size, weights);
private static procedure z_WeightivARB_ovr_0(size: Int32; var weights: Int32);
external 'opengl32.dll' name 'glWeightivARB';
private static procedure z_WeightivARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; weights: array of Int32) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightivARB_ovr_0(size, weights[0]) else
z_WeightivARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; var weights: Int32) :=
z_WeightivARB_ovr_0(size, weights);
private static procedure z_WeightivARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; weights: IntPtr) :=
z_WeightivARB_ovr_2(size, weights);
private static procedure z_WeightfvARB_ovr_0(size: Int32; var weights: single);
external 'opengl32.dll' name 'glWeightfvARB';
private static procedure z_WeightfvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; weights: array of single) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightfvARB_ovr_0(size, weights[0]) else
z_WeightfvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; var weights: single) :=
z_WeightfvARB_ovr_0(size, weights);
private static procedure z_WeightfvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; weights: IntPtr) :=
z_WeightfvARB_ovr_2(size, weights);
private static procedure z_WeightdvARB_ovr_0(size: Int32; var weights: real);
external 'opengl32.dll' name 'glWeightdvARB';
private static procedure z_WeightdvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; weights: array of real) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightdvARB_ovr_0(size, weights[0]) else
z_WeightdvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; var weights: real) :=
z_WeightdvARB_ovr_0(size, weights);
private static procedure z_WeightdvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; weights: IntPtr) :=
z_WeightdvARB_ovr_2(size, weights);
private static procedure z_WeightubvARB_ovr_0(size: Int32; var weights: Byte);
external 'opengl32.dll' name 'glWeightubvARB';
private static procedure z_WeightubvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; weights: array of Byte) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightubvARB_ovr_0(size, weights[0]) else
z_WeightubvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; var weights: Byte) :=
z_WeightubvARB_ovr_0(size, weights);
private static procedure z_WeightubvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; weights: IntPtr) :=
z_WeightubvARB_ovr_2(size, weights);
private static procedure z_WeightusvARB_ovr_0(size: Int32; var weights: UInt16);
external 'opengl32.dll' name 'glWeightusvARB';
private static procedure z_WeightusvARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; weights: array of UInt16) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightusvARB_ovr_0(size, weights[0]) else
z_WeightusvARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; var weights: UInt16) :=
z_WeightusvARB_ovr_0(size, weights);
private static procedure z_WeightusvARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; weights: IntPtr) :=
z_WeightusvARB_ovr_2(size, weights);
private static procedure z_WeightuivARB_ovr_0(size: Int32; var weights: UInt32);
external 'opengl32.dll' name 'glWeightuivARB';
private static procedure z_WeightuivARB_ovr_0_anh001(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; weights: array of UInt32) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightuivARB_ovr_0(size, weights[0]) else
z_WeightuivARB_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; var weights: UInt32) :=
z_WeightuivARB_ovr_0(size, weights);
private static procedure z_WeightuivARB_ovr_2(size: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; weights: IntPtr) :=
z_WeightuivARB_ovr_2(size, weights);
private static procedure z_WeightPointerARB_ovr_0(size: Int32; &type: WeightPointerTypeARB; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glWeightPointerARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPointerARB(size: Int32; &type: WeightPointerTypeARB; stride: Int32; pointer: IntPtr) :=
z_WeightPointerARB_ovr_0(size, &type, stride, pointer);
private static procedure z_VertexBlendARB_ovr_0(count: Int32);
external 'opengl32.dll' name 'glVertexBlendARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendARB(count: Int32) :=
z_VertexBlendARB_ovr_0(count);
end;
[PCUNotRestore]
glVertexBufferObjectARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindBufferARB_ovr_0(target: BufferTargetARB; buffer: UInt32);
external 'opengl32.dll' name 'glBindBufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferARB(target: BufferTargetARB; buffer: UInt32) :=
z_BindBufferARB_ovr_0(target, buffer);
private static procedure z_DeleteBuffersARB_ovr_0(n: Int32; var buffers: UInt32);
external 'opengl32.dll' name 'glDeleteBuffersARB';
private static procedure z_DeleteBuffersARB_ovr_0_anh001(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glDeleteBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; buffers: array of UInt32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_DeleteBuffersARB_ovr_0(n, buffers[0]) else
z_DeleteBuffersARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; var buffers: UInt32) :=
z_DeleteBuffersARB_ovr_0(n, buffers);
private static procedure z_DeleteBuffersARB_ovr_2(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glDeleteBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; buffers: IntPtr) :=
z_DeleteBuffersARB_ovr_2(n, buffers);
private static procedure z_GenBuffersARB_ovr_0(n: Int32; var buffers: UInt32);
external 'opengl32.dll' name 'glGenBuffersARB';
private static procedure z_GenBuffersARB_ovr_0_anh001(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glGenBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; buffers: array of UInt32) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_GenBuffersARB_ovr_0(n, buffers[0]) else
z_GenBuffersARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; var buffers: UInt32) :=
z_GenBuffersARB_ovr_0(n, buffers);
private static procedure z_GenBuffersARB_ovr_2(n: Int32; buffers: IntPtr);
external 'opengl32.dll' name 'glGenBuffersARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; buffers: IntPtr) :=
z_GenBuffersARB_ovr_2(n, buffers);
private static function z_IsBufferARB_ovr_0(buffer: UInt32): boolean;
external 'opengl32.dll' name 'glIsBufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBufferARB(buffer: UInt32): boolean :=
z_IsBufferARB_ovr_0(buffer);
private static procedure z_BufferDataARB_ovr_0(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB);
external 'opengl32.dll' name 'glBufferDataARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferDataARB(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
z_BufferDataARB_ovr_0(target, size, data, usage);
private static procedure z_BufferSubDataARB_ovr_0(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glBufferSubDataARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_BufferSubDataARB_ovr_0(target, offset, size, data);
private static procedure z_GetBufferSubDataARB_ovr_0(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glGetBufferSubDataARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_GetBufferSubDataARB_ovr_0(target, offset, size, data);
private static function z_MapBufferARB_ovr_0(target: BufferTargetARB; access: BufferAccessARB): IntPtr;
external 'opengl32.dll' name 'glMapBufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferARB(target: BufferTargetARB; access: BufferAccessARB): IntPtr :=
z_MapBufferARB_ovr_0(target, access);
private static function z_UnmapBufferARB_ovr_0(target: BufferTargetARB): boolean;
external 'opengl32.dll' name 'glUnmapBufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBufferARB(target: BufferTargetARB): boolean :=
z_UnmapBufferARB_ovr_0(target);
private static procedure z_GetBufferParameterivARB_ovr_0(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetBufferParameterivARB';
private static procedure z_GetBufferParameterivARB_ovr_0_anh0001(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferParameterivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferParameterivARB_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferParameterivARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32) :=
z_GetBufferParameterivARB_ovr_0(target, pname, ¶ms);
private static procedure z_GetBufferParameterivARB_ovr_2(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferParameterivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr) :=
z_GetBufferParameterivARB_ovr_2(target, pname, ¶ms);
private static procedure z_GetBufferPointervARB_ovr_0(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferPointervARB';
private static procedure z_GetBufferPointervARB_ovr_0_anh0001(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferPointervARB_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferPointervARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr) :=
z_GetBufferPointervARB_ovr_0(target, pname, ¶ms);
private static procedure z_GetBufferPointervARB_ovr_2(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer);
external 'opengl32.dll' name 'glGetBufferPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer) :=
z_GetBufferPointervARB_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glVertexProgramARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttrib1dARB_ovr_0(index: UInt32; x: real);
external 'opengl32.dll' name 'glVertexAttrib1dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dARB(index: UInt32; x: real) :=
z_VertexAttrib1dARB_ovr_0(index, x);
private static procedure z_VertexAttrib1dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
private static procedure z_VertexAttrib1dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1dvARB_ovr_0(index, v[0]) else
z_VertexAttrib1dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; var v: real) :=
z_VertexAttrib1dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib1dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib1fARB_ovr_0(index: UInt32; x: single);
external 'opengl32.dll' name 'glVertexAttrib1fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fARB(index: UInt32; x: single) :=
z_VertexAttrib1fARB_ovr_0(index, x);
private static procedure z_VertexAttrib1fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
private static procedure z_VertexAttrib1fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1fvARB_ovr_0(index, v[0]) else
z_VertexAttrib1fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; var v: single) :=
z_VertexAttrib1fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib1fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib1sARB_ovr_0(index: UInt32; x: Int16);
external 'opengl32.dll' name 'glVertexAttrib1sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sARB(index: UInt32; x: Int16) :=
z_VertexAttrib1sARB_ovr_0(index, x);
private static procedure z_VertexAttrib1svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
private static procedure z_VertexAttrib1svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1svARB_ovr_0(index, v[0]) else
z_VertexAttrib1svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib1svARB_ovr_0(index, v);
private static procedure z_VertexAttrib1svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1svARB_ovr_2(index, v);
private static procedure z_VertexAttrib2dARB_ovr_0(index: UInt32; x: real; y: real);
external 'opengl32.dll' name 'glVertexAttrib2dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dARB(index: UInt32; x: real; y: real) :=
z_VertexAttrib2dARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib2dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
private static procedure z_VertexAttrib2dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2dvARB_ovr_0(index, v[0]) else
z_VertexAttrib2dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; var v: real) :=
z_VertexAttrib2dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib2dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib2fARB_ovr_0(index: UInt32; x: single; y: single);
external 'opengl32.dll' name 'glVertexAttrib2fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fARB(index: UInt32; x: single; y: single) :=
z_VertexAttrib2fARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib2fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
private static procedure z_VertexAttrib2fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2fvARB_ovr_0(index, v[0]) else
z_VertexAttrib2fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; var v: single) :=
z_VertexAttrib2fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib2fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib2sARB_ovr_0(index: UInt32; x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertexAttrib2sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sARB(index: UInt32; x: Int16; y: Int16) :=
z_VertexAttrib2sARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib2svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
private static procedure z_VertexAttrib2svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2svARB_ovr_0(index, v[0]) else
z_VertexAttrib2svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib2svARB_ovr_0(index, v);
private static procedure z_VertexAttrib2svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2svARB_ovr_2(index, v);
private static procedure z_VertexAttrib3dARB_ovr_0(index: UInt32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexAttrib3dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dARB(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttrib3dARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
private static procedure z_VertexAttrib3dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3dvARB_ovr_0(index, v[0]) else
z_VertexAttrib3dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; var v: real) :=
z_VertexAttrib3dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib3dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib3fARB_ovr_0(index: UInt32; x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertexAttrib3fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fARB(index: UInt32; x: single; y: single; z: single) :=
z_VertexAttrib3fARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
private static procedure z_VertexAttrib3fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3fvARB_ovr_0(index, v[0]) else
z_VertexAttrib3fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; var v: single) :=
z_VertexAttrib3fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib3fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib3sARB_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertexAttrib3sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sARB(index: UInt32; x: Int16; y: Int16; z: Int16) :=
z_VertexAttrib3sARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
private static procedure z_VertexAttrib3svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3svARB_ovr_0(index, v[0]) else
z_VertexAttrib3svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib3svARB_ovr_0(index, v);
private static procedure z_VertexAttrib3svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3svARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NbvARB_ovr_0(index: UInt32; var v: SByte);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
private static procedure z_VertexAttrib4NbvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NbvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NbvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; var v: SByte) :=
z_VertexAttrib4NbvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NbvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NbvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NivARB_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
private static procedure z_VertexAttrib4NivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NivARB_ovr_0(index, v[0]) else
z_VertexAttrib4NivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; var v: Int32) :=
z_VertexAttrib4NivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NsvARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
private static procedure z_VertexAttrib4NsvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NsvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NsvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; var v: Int16) :=
z_VertexAttrib4NsvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NsvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NsvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NubARB_ovr_0(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
external 'opengl32.dll' name 'glVertexAttrib4NubARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubARB(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte) :=
z_VertexAttrib4NubARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4NubvARB_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
private static procedure z_VertexAttrib4NubvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NubvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NubvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; var v: Byte) :=
z_VertexAttrib4NubvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NubvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NubvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NuivARB_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
private static procedure z_VertexAttrib4NuivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NuivARB_ovr_0(index, v[0]) else
z_VertexAttrib4NuivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; var v: UInt32) :=
z_VertexAttrib4NuivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NuivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NuivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NusvARB_ovr_0(index: UInt32; var v: UInt16);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
private static procedure z_VertexAttrib4NusvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NusvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NusvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; var v: UInt16) :=
z_VertexAttrib4NusvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NusvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NusvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4bvARB_ovr_0(index: UInt32; var v: SByte);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
private static procedure z_VertexAttrib4bvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4bvARB_ovr_0(index, v[0]) else
z_VertexAttrib4bvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; var v: SByte) :=
z_VertexAttrib4bvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4bvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4bvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4dARB_ovr_0(index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexAttrib4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dARB(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttrib4dARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
private static procedure z_VertexAttrib4dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4dvARB_ovr_0(index, v[0]) else
z_VertexAttrib4dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; var v: real) :=
z_VertexAttrib4dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4fARB_ovr_0(index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertexAttrib4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fARB(index: UInt32; x: single; y: single; z: single; w: single) :=
z_VertexAttrib4fARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
private static procedure z_VertexAttrib4fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4fvARB_ovr_0(index, v[0]) else
z_VertexAttrib4fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; var v: single) :=
z_VertexAttrib4fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4ivARB_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
private static procedure z_VertexAttrib4ivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ivARB_ovr_0(index, v[0]) else
z_VertexAttrib4ivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; var v: Int32) :=
z_VertexAttrib4ivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4ivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4sARB_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertexAttrib4sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sARB(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16) :=
z_VertexAttrib4sARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
private static procedure z_VertexAttrib4svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4svARB_ovr_0(index, v[0]) else
z_VertexAttrib4svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib4svARB_ovr_0(index, v);
private static procedure z_VertexAttrib4svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4svARB_ovr_2(index, v);
private static procedure z_VertexAttrib4ubvARB_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
private static procedure z_VertexAttrib4ubvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ubvARB_ovr_0(index, v[0]) else
z_VertexAttrib4ubvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; var v: Byte) :=
z_VertexAttrib4ubvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4ubvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ubvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4uivARB_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
private static procedure z_VertexAttrib4uivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4uivARB_ovr_0(index, v[0]) else
z_VertexAttrib4uivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; var v: UInt32) :=
z_VertexAttrib4uivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4uivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4uivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4usvARB_ovr_0(index: UInt32; var v: UInt16);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
private static procedure z_VertexAttrib4usvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4usvARB_ovr_0(index, v[0]) else
z_VertexAttrib4usvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; var v: UInt16) :=
z_VertexAttrib4usvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4usvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4usvARB_ovr_2(index, v);
private static procedure z_VertexAttribPointerARB_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribPointerARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerARB(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr) :=
z_VertexAttribPointerARB_ovr_0(index, size, &type, normalized, stride, pointer);
private static procedure z_EnableVertexAttribArrayARB_ovr_0(index: UInt32);
external 'opengl32.dll' name 'glEnableVertexAttribArrayARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArrayARB(index: UInt32) :=
z_EnableVertexAttribArrayARB_ovr_0(index);
private static procedure z_DisableVertexAttribArrayARB_ovr_0(index: UInt32);
external 'opengl32.dll' name 'glDisableVertexAttribArrayARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArrayARB(index: UInt32) :=
z_DisableVertexAttribArrayARB_ovr_0(index);
private static procedure z_ProgramStringARB_ovr_0(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
external 'opengl32.dll' name 'glProgramStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramStringARB(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr) :=
z_ProgramStringARB_ovr_0(target, format, len, string);
private static procedure z_BindProgramARB_ovr_0(target: ProgramTarget; &program: UInt32);
external 'opengl32.dll' name 'glBindProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramARB(target: ProgramTarget; &program: UInt32) :=
z_BindProgramARB_ovr_0(target, &program);
private static procedure z_DeleteProgramsARB_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glDeleteProgramsARB';
private static procedure z_DeleteProgramsARB_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_DeleteProgramsARB_ovr_0(n, programs[0]) else
z_DeleteProgramsARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; var programs: UInt32) :=
z_DeleteProgramsARB_ovr_0(n, programs);
private static procedure z_DeleteProgramsARB_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: IntPtr) :=
z_DeleteProgramsARB_ovr_2(n, programs);
private static procedure z_GenProgramsARB_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glGenProgramsARB';
private static procedure z_GenProgramsARB_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_GenProgramsARB_ovr_0(n, programs[0]) else
z_GenProgramsARB_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; var programs: UInt32) :=
z_GenProgramsARB_ovr_0(n, programs);
private static procedure z_GenProgramsARB_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: IntPtr) :=
z_GenProgramsARB_ovr_2(n, programs);
private static procedure z_ProgramEnvParameter4dARB_ovr_0(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramEnvParameter4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real) :=
z_ProgramEnvParameter4dARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameter4dvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
private static procedure z_ProgramEnvParameter4dvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameter4dvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4dvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameter4dvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4fARB_ovr_0(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramEnvParameter4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single) :=
z_ProgramEnvParameter4fARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameter4fvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
private static procedure z_ProgramEnvParameter4fvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameter4fvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameter4fvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameter4fvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4dARB_ovr_0(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramLocalParameter4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real) :=
z_ProgramLocalParameter4dARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameter4dvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
private static procedure z_ProgramLocalParameter4dvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameter4dvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4dvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameter4dvARB_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4fARB_ovr_0(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramLocalParameter4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single) :=
z_ProgramLocalParameter4fARB_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameter4fvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
private static procedure z_ProgramLocalParameter4fvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameter4fvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameter4fvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameter4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameter4fvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterdvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
private static procedure z_GetProgramEnvParameterdvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterdvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterdvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterdvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterfvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
private static procedure z_GetProgramEnvParameterfvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterfvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterfvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterfvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterdvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
private static procedure z_GetProgramLocalParameterdvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterdvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterdvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterdvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterfvARB_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
private static procedure z_GetProgramLocalParameterfvARB_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterfvARB_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterfvARB_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterfvARB_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramivARB_ovr_0(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramivARB';
private static procedure z_GetProgramivARB_ovr_0_anh0001(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramivARB_ovr_0(target, pname, ¶ms[0]) else
z_GetProgramivARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32) :=
z_GetProgramivARB_ovr_0(target, pname, ¶ms);
private static procedure z_GetProgramivARB_ovr_2(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr) :=
z_GetProgramivARB_ovr_2(target, pname, ¶ms);
private static procedure z_GetProgramStringARB_ovr_0(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
external 'opengl32.dll' name 'glGetProgramStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringARB(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr) :=
z_GetProgramStringARB_ovr_0(target, pname, string);
private static procedure z_GetVertexAttribdvARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
private static procedure z_GetVertexAttribdvARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribdvARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real) :=
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribdvARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribdvARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
private static procedure z_GetVertexAttribfvARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribfvARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single) :=
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribfvARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribivARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
private static procedure z_GetVertexAttribivARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribivARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32) :=
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribivARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribivARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribPointervARB_ovr_0(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
private static procedure z_GetVertexAttribPointervARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer[0]) else
z_GetVertexAttribPointervARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr) :=
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer);
private static procedure z_GetVertexAttribPointervARB_ovr_2(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer) :=
z_GetVertexAttribPointervARB_ovr_2(index, pname, _pointer);
private static function z_IsProgramARB_ovr_0(&program: UInt32): boolean;
external 'opengl32.dll' name 'glIsProgramARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramARB(&program: UInt32): boolean :=
z_IsProgramARB_ovr_0(&program);
end;
[PCUNotRestore]
glVertexShaderARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttrib1fARB_ovr_0(index: UInt32; x: single);
external 'opengl32.dll' name 'glVertexAttrib1fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fARB(index: UInt32; x: single) :=
z_VertexAttrib1fARB_ovr_0(index, x);
private static procedure z_VertexAttrib1sARB_ovr_0(index: UInt32; x: Int16);
external 'opengl32.dll' name 'glVertexAttrib1sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sARB(index: UInt32; x: Int16) :=
z_VertexAttrib1sARB_ovr_0(index, x);
private static procedure z_VertexAttrib1dARB_ovr_0(index: UInt32; x: real);
external 'opengl32.dll' name 'glVertexAttrib1dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dARB(index: UInt32; x: real) :=
z_VertexAttrib1dARB_ovr_0(index, x);
private static procedure z_VertexAttrib2fARB_ovr_0(index: UInt32; x: single; y: single);
external 'opengl32.dll' name 'glVertexAttrib2fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fARB(index: UInt32; x: single; y: single) :=
z_VertexAttrib2fARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib2sARB_ovr_0(index: UInt32; x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertexAttrib2sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sARB(index: UInt32; x: Int16; y: Int16) :=
z_VertexAttrib2sARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib2dARB_ovr_0(index: UInt32; x: real; y: real);
external 'opengl32.dll' name 'glVertexAttrib2dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dARB(index: UInt32; x: real; y: real) :=
z_VertexAttrib2dARB_ovr_0(index, x, y);
private static procedure z_VertexAttrib3fARB_ovr_0(index: UInt32; x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertexAttrib3fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fARB(index: UInt32; x: single; y: single; z: single) :=
z_VertexAttrib3fARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3sARB_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertexAttrib3sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sARB(index: UInt32; x: Int16; y: Int16; z: Int16) :=
z_VertexAttrib3sARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3dARB_ovr_0(index: UInt32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexAttrib3dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dARB(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttrib3dARB_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib4fARB_ovr_0(index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertexAttrib4fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fARB(index: UInt32; x: single; y: single; z: single; w: single) :=
z_VertexAttrib4fARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4sARB_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertexAttrib4sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sARB(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16) :=
z_VertexAttrib4sARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4dARB_ovr_0(index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexAttrib4dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dARB(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttrib4dARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4NubARB_ovr_0(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
external 'opengl32.dll' name 'glVertexAttrib4NubARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubARB(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte) :=
z_VertexAttrib4NubARB_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib1fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
private static procedure z_VertexAttrib1fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1fvARB_ovr_0(index, v[0]) else
z_VertexAttrib1fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; var v: single) :=
z_VertexAttrib1fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib1fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib1svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
private static procedure z_VertexAttrib1svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1svARB_ovr_0(index, v[0]) else
z_VertexAttrib1svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib1svARB_ovr_0(index, v);
private static procedure z_VertexAttrib1svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1svARB_ovr_2(index, v);
private static procedure z_VertexAttrib1dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
private static procedure z_VertexAttrib1dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1dvARB_ovr_0(index, v[0]) else
z_VertexAttrib1dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; var v: real) :=
z_VertexAttrib1dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib1dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib1dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib2fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
private static procedure z_VertexAttrib2fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2fvARB_ovr_0(index, v[0]) else
z_VertexAttrib2fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; var v: single) :=
z_VertexAttrib2fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib2fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib2svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
private static procedure z_VertexAttrib2svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2svARB_ovr_0(index, v[0]) else
z_VertexAttrib2svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib2svARB_ovr_0(index, v);
private static procedure z_VertexAttrib2svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2svARB_ovr_2(index, v);
private static procedure z_VertexAttrib2dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
private static procedure z_VertexAttrib2dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2dvARB_ovr_0(index, v[0]) else
z_VertexAttrib2dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; var v: real) :=
z_VertexAttrib2dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib2dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib2dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib3fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
private static procedure z_VertexAttrib3fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3fvARB_ovr_0(index, v[0]) else
z_VertexAttrib3fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; var v: single) :=
z_VertexAttrib3fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib3fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib3svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
private static procedure z_VertexAttrib3svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3svARB_ovr_0(index, v[0]) else
z_VertexAttrib3svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib3svARB_ovr_0(index, v);
private static procedure z_VertexAttrib3svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3svARB_ovr_2(index, v);
private static procedure z_VertexAttrib3dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
private static procedure z_VertexAttrib3dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3dvARB_ovr_0(index, v[0]) else
z_VertexAttrib3dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; var v: real) :=
z_VertexAttrib3dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib3dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib3dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4fvARB_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
private static procedure z_VertexAttrib4fvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4fvARB_ovr_0(index, v[0]) else
z_VertexAttrib4fvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; var v: single) :=
z_VertexAttrib4fvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4fvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4fvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4svARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
private static procedure z_VertexAttrib4svARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4svARB_ovr_0(index, v[0]) else
z_VertexAttrib4svARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; var v: Int16) :=
z_VertexAttrib4svARB_ovr_0(index, v);
private static procedure z_VertexAttrib4svARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4svARB_ovr_2(index, v);
private static procedure z_VertexAttrib4dvARB_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
private static procedure z_VertexAttrib4dvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4dvARB_ovr_0(index, v[0]) else
z_VertexAttrib4dvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; var v: real) :=
z_VertexAttrib4dvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4dvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4dvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4ivARB_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
private static procedure z_VertexAttrib4ivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ivARB_ovr_0(index, v[0]) else
z_VertexAttrib4ivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; var v: Int32) :=
z_VertexAttrib4ivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4ivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4bvARB_ovr_0(index: UInt32; var v: SByte);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
private static procedure z_VertexAttrib4bvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4bvARB_ovr_0(index, v[0]) else
z_VertexAttrib4bvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; var v: SByte) :=
z_VertexAttrib4bvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4bvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4bvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4bvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4ubvARB_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
private static procedure z_VertexAttrib4ubvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ubvARB_ovr_0(index, v[0]) else
z_VertexAttrib4ubvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; var v: Byte) :=
z_VertexAttrib4ubvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4ubvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ubvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4usvARB_ovr_0(index: UInt32; var v: UInt16);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
private static procedure z_VertexAttrib4usvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4usvARB_ovr_0(index, v[0]) else
z_VertexAttrib4usvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; var v: UInt16) :=
z_VertexAttrib4usvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4usvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4usvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4usvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4uivARB_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
private static procedure z_VertexAttrib4uivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4uivARB_ovr_0(index, v[0]) else
z_VertexAttrib4uivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; var v: UInt32) :=
z_VertexAttrib4uivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4uivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4uivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4uivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NbvARB_ovr_0(index: UInt32; var v: SByte);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
private static procedure z_VertexAttrib4NbvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NbvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NbvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; var v: SByte) :=
z_VertexAttrib4NbvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NbvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NbvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NbvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NsvARB_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
private static procedure z_VertexAttrib4NsvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NsvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NsvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; var v: Int16) :=
z_VertexAttrib4NsvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NsvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NsvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NsvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NivARB_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
private static procedure z_VertexAttrib4NivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NivARB_ovr_0(index, v[0]) else
z_VertexAttrib4NivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; var v: Int32) :=
z_VertexAttrib4NivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NivARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NubvARB_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
private static procedure z_VertexAttrib4NubvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NubvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NubvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; var v: Byte) :=
z_VertexAttrib4NubvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NubvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NubvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NubvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NusvARB_ovr_0(index: UInt32; var v: UInt16);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
private static procedure z_VertexAttrib4NusvARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NusvARB_ovr_0(index, v[0]) else
z_VertexAttrib4NusvARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; var v: UInt16) :=
z_VertexAttrib4NusvARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NusvARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NusvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NusvARB_ovr_2(index, v);
private static procedure z_VertexAttrib4NuivARB_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
private static procedure z_VertexAttrib4NuivARB_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4NuivARB_ovr_0(index, v[0]) else
z_VertexAttrib4NuivARB_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; var v: UInt32) :=
z_VertexAttrib4NuivARB_ovr_0(index, v);
private static procedure z_VertexAttrib4NuivARB_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4NuivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: IntPtr) :=
z_VertexAttrib4NuivARB_ovr_2(index, v);
private static procedure z_VertexAttribPointerARB_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribPointerARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerARB(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr) :=
z_VertexAttribPointerARB_ovr_0(index, size, &type, normalized, stride, pointer);
private static procedure z_EnableVertexAttribArrayARB_ovr_0(index: UInt32);
external 'opengl32.dll' name 'glEnableVertexAttribArrayARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArrayARB(index: UInt32) :=
z_EnableVertexAttribArrayARB_ovr_0(index);
private static procedure z_DisableVertexAttribArrayARB_ovr_0(index: UInt32);
external 'opengl32.dll' name 'glDisableVertexAttribArrayARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArrayARB(index: UInt32) :=
z_DisableVertexAttribArrayARB_ovr_0(index);
private static procedure z_BindAttribLocationARB_ovr_0(programObj: GLhandleARB; index: UInt32; name: IntPtr);
external 'opengl32.dll' name 'glBindAttribLocationARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindAttribLocationARB(programObj: GLhandleARB; index: UInt32; name: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindAttribLocationARB_ovr_0(programObj, index, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindAttribLocationARB(programObj: GLhandleARB; index: UInt32; name: IntPtr) :=
z_BindAttribLocationARB_ovr_0(programObj, index, name);
private static procedure z_GetActiveAttribARB_ovr_0(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00000110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_0_anh00001110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000010(programObj, index, maxLength, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000110(programObj, index, maxLength, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00001010(programObj, index, maxLength, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00001110(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveAttribARB_ovr_1_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_1_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_1_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type, name) else
z_GetActiveAttribARB_ovr_0_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type, name) else
z_GetActiveAttribARB_ovr_0_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveAttribARB_ovr_2(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_2_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_2_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_2_anh00001100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length[0], size[0], &type, name) else
z_GetActiveAttribARB_ovr_2_anh00000100(programObj, index, maxLength, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_2_anh00001000(programObj, index, maxLength, IntPtr.Zero, size[0], &type, name) else
z_GetActiveAttribARB_ovr_2_anh00001100(programObj, index, maxLength, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveAttribARB_ovr_3_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_3_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000010(programObj, index, maxLength, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00001010(programObj, index, maxLength, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveAttribARB_ovr_4_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveAttribARB_ovr_0_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_5_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveAttribARB_ovr_2_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_6(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_6_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_6_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_6_anh00001010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length[0], size, &type[0], name) else
z_GetActiveAttribARB_ovr_6_anh00000010(programObj, index, maxLength, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_6_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type[0], name) else
z_GetActiveAttribARB_ovr_6_anh00001010(programObj, index, maxLength, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveAttribARB_ovr_7_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveAttribARB_ovr_6_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_8(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_8_anh00001000(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveAttribARB_ovr_8(programObj, index, maxLength, length[0], size, &type, name) else
z_GetActiveAttribARB_ovr_8_anh00001000(programObj, index, maxLength, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size[0], &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000010(programObj, index, maxLength, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000110(programObj, index, maxLength, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveAttribARB_ovr_0_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveAttribARB_ovr_2_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveAttribARB_ovr_0_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveAttribARB_ovr_6_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttribARB_ovr_8(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_18(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_18_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_18_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_18_anh00000110(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: array of AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size[0], &type[0], name) else
z_GetActiveAttribARB_ovr_18_anh00000010(programObj, index, maxLength, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_18_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type[0], name) else
z_GetActiveAttribARB_ovr_18_anh00000110(programObj, index, maxLength, length, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveAttribARB_ovr_19_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; var &type: AttributeType; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveAttribARB_ovr_18_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
private static procedure z_GetActiveAttribARB_ovr_20(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_20_anh00000100(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveAttribARB_ovr_20(programObj, index, maxLength, length, size[0], &type, name) else
z_GetActiveAttribARB_ovr_20_anh00000100(programObj, index, maxLength, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveAttribARB_ovr_18_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttribARB_ovr_20(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_24(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
private static procedure z_GetActiveAttribARB_ovr_24_anh00000010(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: array of AttributeType; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveAttribARB_ovr_24(programObj, index, maxLength, length, size, &type[0], name) else
z_GetActiveAttribARB_ovr_24_anh00000010(programObj, index, maxLength, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr) :=
z_GetActiveAttribARB_ovr_24(programObj, index, maxLength, length, size, &type, name);
private static procedure z_GetActiveAttribARB_ovr_26(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveAttribARB_ovr_26(programObj, index, maxLength, length, size, &type, name);
private static function z_GetAttribLocationARB_ovr_0(programObj: GLhandleARB; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetAttribLocationARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetAttribLocationARB(programObj: GLhandleARB; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetAttribLocationARB_ovr_0(programObj, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetAttribLocationARB(programObj: GLhandleARB; name: IntPtr): Int32 :=
z_GetAttribLocationARB_ovr_0(programObj, name);
private static procedure z_GetVertexAttribdvARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
private static procedure z_GetVertexAttribdvARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribdvARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real) :=
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribdvARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribdvARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
private static procedure z_GetVertexAttribfvARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribfvARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single) :=
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribfvARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribivARB_ovr_0(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
private static procedure z_GetVertexAttribivARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribivARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32) :=
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribivARB_ovr_2(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr) :=
z_GetVertexAttribivARB_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribPointervARB_ovr_0(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
private static procedure z_GetVertexAttribPointervARB_ovr_0_anh0001(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer[0]) else
z_GetVertexAttribPointervARB_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr) :=
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer);
private static procedure z_GetVertexAttribPointervARB_ovr_2(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer);
external 'opengl32.dll' name 'glGetVertexAttribPointervARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer) :=
z_GetVertexAttribPointervARB_ovr_2(index, pname, _pointer);
end;
[PCUNotRestore]
glVertexType2101010RevARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribP1ui_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP1ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP1ui_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP1uiv_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP1uiv';
private static procedure z_VertexAttribP1uiv_ovr_0_anh00001(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP1uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP1uiv_ovr_2(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP1uiv_ovr_2(index, &type, normalized, value);
private static procedure z_VertexAttribP2ui_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP2ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP2ui_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP2uiv_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP2uiv';
private static procedure z_VertexAttribP2uiv_ovr_0_anh00001(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP2uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP2uiv_ovr_2(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP2uiv_ovr_2(index, &type, normalized, value);
private static procedure z_VertexAttribP3ui_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP3ui_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP3uiv_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP3uiv';
private static procedure z_VertexAttribP3uiv_ovr_0_anh00001(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP3uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP3uiv_ovr_2(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP3uiv_ovr_2(index, &type, normalized, value);
private static procedure z_VertexAttribP4ui_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4ui(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: UInt32) :=
z_VertexAttribP4ui_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP4uiv_ovr_0(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
external 'opengl32.dll' name 'glVertexAttribP4uiv';
private static procedure z_VertexAttribP4uiv_ovr_0_anh00001(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value[0]) else
z_VertexAttribP4uiv_ovr_0_anh00001(index, &type, normalized, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32) :=
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value);
private static procedure z_VertexAttribP4uiv_ovr_2(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr);
external 'opengl32.dll' name 'glVertexAttribP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: IntPtr) :=
z_VertexAttribP4uiv_ovr_2(index, &type, normalized, value);
private static procedure z_VertexP2ui_ovr_0(&type: VertexPointerType; value: UInt32);
external 'opengl32.dll' name 'glVertexP2ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP2ui_ovr_0(&type, value);
private static procedure z_VertexP2uiv_ovr_0(&type: VertexPointerType; var value: UInt32);
external 'opengl32.dll' name 'glVertexP2uiv';
private static procedure z_VertexP2uiv_ovr_0_anh001(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP2uiv_ovr_0(&type, value[0]) else
z_VertexP2uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP2uiv_ovr_0(&type, value);
private static procedure z_VertexP2uiv_ovr_2(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP2uiv_ovr_2(&type, value);
private static procedure z_VertexP3ui_ovr_0(&type: VertexPointerType; value: UInt32);
external 'opengl32.dll' name 'glVertexP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP3ui_ovr_0(&type, value);
private static procedure z_VertexP3uiv_ovr_0(&type: VertexPointerType; var value: UInt32);
external 'opengl32.dll' name 'glVertexP3uiv';
private static procedure z_VertexP3uiv_ovr_0_anh001(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP3uiv_ovr_0(&type, value[0]) else
z_VertexP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP3uiv_ovr_0(&type, value);
private static procedure z_VertexP3uiv_ovr_2(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP3uiv_ovr_2(&type, value);
private static procedure z_VertexP4ui_ovr_0(&type: VertexPointerType; value: UInt32);
external 'opengl32.dll' name 'glVertexP4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4ui(&type: VertexPointerType; value: UInt32) :=
z_VertexP4ui_ovr_0(&type, value);
private static procedure z_VertexP4uiv_ovr_0(&type: VertexPointerType; var value: UInt32);
external 'opengl32.dll' name 'glVertexP4uiv';
private static procedure z_VertexP4uiv_ovr_0_anh001(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_VertexP4uiv_ovr_0(&type, value[0]) else
z_VertexP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; var value: UInt32) :=
z_VertexP4uiv_ovr_0(&type, value);
private static procedure z_VertexP4uiv_ovr_2(&type: VertexPointerType; value: IntPtr);
external 'opengl32.dll' name 'glVertexP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: IntPtr) :=
z_VertexP4uiv_ovr_2(&type, value);
private static procedure z_TexCoordP1ui_ovr_0(&type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP1ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP1ui_ovr_0(&type, coords);
private static procedure z_TexCoordP1uiv_ovr_0(&type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP1uiv';
private static procedure z_TexCoordP1uiv_ovr_0_anh001(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP1uiv_ovr_0(&type, coords[0]) else
z_TexCoordP1uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP1uiv_ovr_0(&type, coords);
private static procedure z_TexCoordP1uiv_ovr_2(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP1uiv_ovr_2(&type, coords);
private static procedure z_TexCoordP2ui_ovr_0(&type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP2ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP2ui_ovr_0(&type, coords);
private static procedure z_TexCoordP2uiv_ovr_0(&type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP2uiv';
private static procedure z_TexCoordP2uiv_ovr_0_anh001(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP2uiv_ovr_0(&type, coords[0]) else
z_TexCoordP2uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP2uiv_ovr_0(&type, coords);
private static procedure z_TexCoordP2uiv_ovr_2(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP2uiv_ovr_2(&type, coords);
private static procedure z_TexCoordP3ui_ovr_0(&type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP3ui_ovr_0(&type, coords);
private static procedure z_TexCoordP3uiv_ovr_0(&type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP3uiv';
private static procedure z_TexCoordP3uiv_ovr_0_anh001(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP3uiv_ovr_0(&type, coords[0]) else
z_TexCoordP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP3uiv_ovr_0(&type, coords);
private static procedure z_TexCoordP3uiv_ovr_2(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP3uiv_ovr_2(&type, coords);
private static procedure z_TexCoordP4ui_ovr_0(&type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4ui(&type: TexCoordPointerType; coords: UInt32) :=
z_TexCoordP4ui_ovr_0(&type, coords);
private static procedure z_TexCoordP4uiv_ovr_0(&type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glTexCoordP4uiv';
private static procedure z_TexCoordP4uiv_ovr_0_anh001(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoordP4uiv_ovr_0(&type, coords[0]) else
z_TexCoordP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; var coords: UInt32) :=
z_TexCoordP4uiv_ovr_0(&type, coords);
private static procedure z_TexCoordP4uiv_ovr_2(&type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glTexCoordP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: IntPtr) :=
z_TexCoordP4uiv_ovr_2(&type, coords);
private static procedure z_MultiTexCoordP1ui_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP1ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP1ui_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP1uiv_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP1uiv';
private static procedure z_MultiTexCoordP1uiv_ovr_0_anh0001(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP1uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP1uiv_ovr_2(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP1uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP1uiv_ovr_2(texture, &type, coords);
private static procedure z_MultiTexCoordP2ui_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP2ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP2ui_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP2uiv_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP2uiv';
private static procedure z_MultiTexCoordP2uiv_ovr_0_anh0001(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP2uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP2uiv_ovr_2(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP2uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP2uiv_ovr_2(texture, &type, coords);
private static procedure z_MultiTexCoordP3ui_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP3ui_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP3uiv_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP3uiv';
private static procedure z_MultiTexCoordP3uiv_ovr_0_anh0001(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP3uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP3uiv_ovr_2(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP3uiv_ovr_2(texture, &type, coords);
private static procedure z_MultiTexCoordP4ui_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4ui(texture: TextureUnit; &type: TexCoordPointerType; coords: UInt32) :=
z_MultiTexCoordP4ui_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP4uiv_ovr_0(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glMultiTexCoordP4uiv';
private static procedure z_MultiTexCoordP4uiv_ovr_0_anh0001(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords[0]) else
z_MultiTexCoordP4uiv_ovr_0_anh0001(texture, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32) :=
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords);
private static procedure z_MultiTexCoordP4uiv_ovr_2(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: IntPtr) :=
z_MultiTexCoordP4uiv_ovr_2(texture, &type, coords);
private static procedure z_NormalP3ui_ovr_0(&type: NormalPointerType; coords: UInt32);
external 'opengl32.dll' name 'glNormalP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3ui(&type: NormalPointerType; coords: UInt32) :=
z_NormalP3ui_ovr_0(&type, coords);
private static procedure z_NormalP3uiv_ovr_0(&type: NormalPointerType; var coords: UInt32);
external 'opengl32.dll' name 'glNormalP3uiv';
private static procedure z_NormalP3uiv_ovr_0_anh001(&type: NormalPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glNormalP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: array of UInt32) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalP3uiv_ovr_0(&type, coords[0]) else
z_NormalP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; var coords: UInt32) :=
z_NormalP3uiv_ovr_0(&type, coords);
private static procedure z_NormalP3uiv_ovr_2(&type: NormalPointerType; coords: IntPtr);
external 'opengl32.dll' name 'glNormalP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: IntPtr) :=
z_NormalP3uiv_ovr_2(&type, coords);
private static procedure z_ColorP3ui_ovr_0(&type: ColorPointerType; color: UInt32);
external 'opengl32.dll' name 'glColorP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3ui(&type: ColorPointerType; color: UInt32) :=
z_ColorP3ui_ovr_0(&type, color);
private static procedure z_ColorP3uiv_ovr_0(&type: ColorPointerType; var color: UInt32);
external 'opengl32.dll' name 'glColorP3uiv';
private static procedure z_ColorP3uiv_ovr_0_anh001(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glColorP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_ColorP3uiv_ovr_0(&type, color[0]) else
z_ColorP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; var color: UInt32) :=
z_ColorP3uiv_ovr_0(&type, color);
private static procedure z_ColorP3uiv_ovr_2(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glColorP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: IntPtr) :=
z_ColorP3uiv_ovr_2(&type, color);
private static procedure z_ColorP4ui_ovr_0(&type: ColorPointerType; color: UInt32);
external 'opengl32.dll' name 'glColorP4ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4ui(&type: ColorPointerType; color: UInt32) :=
z_ColorP4ui_ovr_0(&type, color);
private static procedure z_ColorP4uiv_ovr_0(&type: ColorPointerType; var color: UInt32);
external 'opengl32.dll' name 'glColorP4uiv';
private static procedure z_ColorP4uiv_ovr_0_anh001(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glColorP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_ColorP4uiv_ovr_0(&type, color[0]) else
z_ColorP4uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; var color: UInt32) :=
z_ColorP4uiv_ovr_0(&type, color);
private static procedure z_ColorP4uiv_ovr_2(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glColorP4uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: IntPtr) :=
z_ColorP4uiv_ovr_2(&type, color);
private static procedure z_SecondaryColorP3ui_ovr_0(&type: ColorPointerType; color: UInt32);
external 'opengl32.dll' name 'glSecondaryColorP3ui';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3ui(&type: ColorPointerType; color: UInt32) :=
z_SecondaryColorP3ui_ovr_0(&type, color);
private static procedure z_SecondaryColorP3uiv_ovr_0(&type: ColorPointerType; var color: UInt32);
external 'opengl32.dll' name 'glSecondaryColorP3uiv';
private static procedure z_SecondaryColorP3uiv_ovr_0_anh001(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glSecondaryColorP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: array of UInt32) :=
if (color<>nil) and (color.Length<>0) then
z_SecondaryColorP3uiv_ovr_0(&type, color[0]) else
z_SecondaryColorP3uiv_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; var color: UInt32) :=
z_SecondaryColorP3uiv_ovr_0(&type, color);
private static procedure z_SecondaryColorP3uiv_ovr_2(&type: ColorPointerType; color: IntPtr);
external 'opengl32.dll' name 'glSecondaryColorP3uiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: IntPtr) :=
z_SecondaryColorP3uiv_ovr_2(&type, color);
end;
[PCUNotRestore]
glViewportArrayARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ViewportArrayv_ovr_0(first: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glViewportArrayv';
private static procedure z_ViewportArrayv_ovr_0_anh0001(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glViewportArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ViewportArrayv_ovr_0(first, count, v[0]) else
z_ViewportArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; var v: single) :=
z_ViewportArrayv_ovr_0(first, count, v);
private static procedure z_ViewportArrayv_ovr_2(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glViewportArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_ViewportArrayv_ovr_2(first, count, v);
private static procedure z_ViewportIndexedf_ovr_0(index: UInt32; x: single; y: single; w: single; h: single);
external 'opengl32.dll' name 'glViewportIndexedf';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedf(index: UInt32; x: single; y: single; w: single; h: single) :=
z_ViewportIndexedf_ovr_0(index, x, y, w, h);
private static procedure z_ViewportIndexedfv_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glViewportIndexedfv';
private static procedure z_ViewportIndexedfv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glViewportIndexedfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ViewportIndexedfv_ovr_0(index, v[0]) else
z_ViewportIndexedfv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; var v: single) :=
z_ViewportIndexedfv_ovr_0(index, v);
private static procedure z_ViewportIndexedfv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glViewportIndexedfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: IntPtr) :=
z_ViewportIndexedfv_ovr_2(index, v);
private static procedure z_ScissorArrayv_ovr_0(first: UInt32; count: Int32; var v: Int32);
external 'opengl32.dll' name 'glScissorArrayv';
private static procedure z_ScissorArrayv_ovr_0_anh0001(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glScissorArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_ScissorArrayv_ovr_0(first, count, v[0]) else
z_ScissorArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; var v: Int32) :=
z_ScissorArrayv_ovr_0(first, count, v);
private static procedure z_ScissorArrayv_ovr_2(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glScissorArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_ScissorArrayv_ovr_2(first, count, v);
private static procedure z_ScissorIndexed_ovr_0(index: UInt32; left: Int32; bottom: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glScissorIndexed';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexed(index: UInt32; left: Int32; bottom: Int32; width: Int32; height: Int32) :=
z_ScissorIndexed_ovr_0(index, left, bottom, width, height);
private static procedure z_ScissorIndexedv_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glScissorIndexedv';
private static procedure z_ScissorIndexedv_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glScissorIndexedv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_ScissorIndexedv_ovr_0(index, v[0]) else
z_ScissorIndexedv_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; var v: Int32) :=
z_ScissorIndexedv_ovr_0(index, v);
private static procedure z_ScissorIndexedv_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glScissorIndexedv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: IntPtr) :=
z_ScissorIndexedv_ovr_2(index, v);
private static procedure z_DepthRangeArrayv_ovr_0(first: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glDepthRangeArrayv';
private static procedure z_DepthRangeArrayv_ovr_0_anh0001(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glDepthRangeArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_DepthRangeArrayv_ovr_0(first, count, v[0]) else
z_DepthRangeArrayv_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; var v: real) :=
z_DepthRangeArrayv_ovr_0(first, count, v);
private static procedure z_DepthRangeArrayv_ovr_2(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glDepthRangeArrayv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; v: IntPtr) :=
z_DepthRangeArrayv_ovr_2(first, count, v);
private static procedure z_DepthRangeIndexed_ovr_0(index: UInt32; n: real; f: real);
external 'opengl32.dll' name 'glDepthRangeIndexed';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeIndexed(index: UInt32; n: real; f: real) :=
z_DepthRangeIndexed_ovr_0(index, n, f);
private static procedure z_GetFloati_v_ovr_0(target: DummyEnum; index: UInt32; var data: single);
external 'opengl32.dll' name 'glGetFloati_v';
private static procedure z_GetFloati_v_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetFloati_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetFloati_v_ovr_0(target, index, data[0]) else
z_GetFloati_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; var data: single) :=
z_GetFloati_v_ovr_0(target, index, data);
private static procedure z_GetFloati_v_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetFloati_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetFloati_v_ovr_2(target, index, data);
private static procedure z_GetDoublei_v_ovr_0(target: DummyEnum; index: UInt32; var data: real);
external 'opengl32.dll' name 'glGetDoublei_v';
private static procedure z_GetDoublei_v_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetDoublei_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; data: array of real) :=
if (data<>nil) and (data.Length<>0) then
z_GetDoublei_v_ovr_0(target, index, data[0]) else
z_GetDoublei_v_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; var data: real) :=
z_GetDoublei_v_ovr_0(target, index, data);
private static procedure z_GetDoublei_v_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetDoublei_v';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetDoublei_v_ovr_2(target, index, data);
private static procedure z_DepthRangeArraydvNV_ovr_0(first: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glDepthRangeArraydvNV';
private static procedure z_DepthRangeArraydvNV_ovr_0_anh0001(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glDepthRangeArraydvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArraydvNV(first: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_DepthRangeArraydvNV_ovr_0(first, count, v[0]) else
z_DepthRangeArraydvNV_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArraydvNV(first: UInt32; count: Int32; var v: real) :=
z_DepthRangeArraydvNV_ovr_0(first, count, v);
private static procedure z_DepthRangeArraydvNV_ovr_2(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glDepthRangeArraydvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArraydvNV(first: UInt32; count: Int32; v: IntPtr) :=
z_DepthRangeArraydvNV_ovr_2(first, count, v);
private static procedure z_DepthRangeIndexeddNV_ovr_0(index: UInt32; n: real; f: real);
external 'opengl32.dll' name 'glDepthRangeIndexeddNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeIndexeddNV(index: UInt32; n: real; f: real) :=
z_DepthRangeIndexeddNV_ovr_0(index, n, f);
end;
[PCUNotRestore]
glWindowPosARB = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_WindowPos2dARB_ovr_0(x: real; y: real);
external 'opengl32.dll' name 'glWindowPos2dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dARB(x: real; y: real) :=
z_WindowPos2dARB_ovr_0(x, y);
private static procedure z_WindowPos2dvARB_ovr_0(var v: real);
external 'opengl32.dll' name 'glWindowPos2dvARB';
private static procedure z_WindowPos2dvARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2dvARB_ovr_0(v[0]) else
z_WindowPos2dvARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(var v: real) :=
z_WindowPos2dvARB_ovr_0(v);
private static procedure z_WindowPos2dvARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(v: IntPtr) :=
z_WindowPos2dvARB_ovr_2(v);
private static procedure z_WindowPos2fARB_ovr_0(x: single; y: single);
external 'opengl32.dll' name 'glWindowPos2fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fARB(x: single; y: single) :=
z_WindowPos2fARB_ovr_0(x, y);
private static procedure z_WindowPos2fvARB_ovr_0(var v: single);
external 'opengl32.dll' name 'glWindowPos2fvARB';
private static procedure z_WindowPos2fvARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2fvARB_ovr_0(v[0]) else
z_WindowPos2fvARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(var v: single) :=
z_WindowPos2fvARB_ovr_0(v);
private static procedure z_WindowPos2fvARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(v: IntPtr) :=
z_WindowPos2fvARB_ovr_2(v);
private static procedure z_WindowPos2iARB_ovr_0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glWindowPos2iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iARB(x: Int32; y: Int32) :=
z_WindowPos2iARB_ovr_0(x, y);
private static procedure z_WindowPos2ivARB_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glWindowPos2ivARB';
private static procedure z_WindowPos2ivARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2ivARB_ovr_0(v[0]) else
z_WindowPos2ivARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(var v: Int32) :=
z_WindowPos2ivARB_ovr_0(v);
private static procedure z_WindowPos2ivARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(v: IntPtr) :=
z_WindowPos2ivARB_ovr_2(v);
private static procedure z_WindowPos2sARB_ovr_0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glWindowPos2sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sARB(x: Int16; y: Int16) :=
z_WindowPos2sARB_ovr_0(x, y);
private static procedure z_WindowPos2svARB_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glWindowPos2svARB';
private static procedure z_WindowPos2svARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2svARB_ovr_0(v[0]) else
z_WindowPos2svARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(var v: Int16) :=
z_WindowPos2svARB_ovr_0(v);
private static procedure z_WindowPos2svARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(v: IntPtr) :=
z_WindowPos2svARB_ovr_2(v);
private static procedure z_WindowPos3dARB_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glWindowPos3dARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dARB(x: real; y: real; z: real) :=
z_WindowPos3dARB_ovr_0(x, y, z);
private static procedure z_WindowPos3dvARB_ovr_0(var v: real);
external 'opengl32.dll' name 'glWindowPos3dvARB';
private static procedure z_WindowPos3dvARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3dvARB_ovr_0(v[0]) else
z_WindowPos3dvARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(var v: real) :=
z_WindowPos3dvARB_ovr_0(v);
private static procedure z_WindowPos3dvARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3dvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(v: IntPtr) :=
z_WindowPos3dvARB_ovr_2(v);
private static procedure z_WindowPos3fARB_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glWindowPos3fARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fARB(x: single; y: single; z: single) :=
z_WindowPos3fARB_ovr_0(x, y, z);
private static procedure z_WindowPos3fvARB_ovr_0(var v: single);
external 'opengl32.dll' name 'glWindowPos3fvARB';
private static procedure z_WindowPos3fvARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3fvARB_ovr_0(v[0]) else
z_WindowPos3fvARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(var v: single) :=
z_WindowPos3fvARB_ovr_0(v);
private static procedure z_WindowPos3fvARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3fvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(v: IntPtr) :=
z_WindowPos3fvARB_ovr_2(v);
private static procedure z_WindowPos3iARB_ovr_0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glWindowPos3iARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iARB(x: Int32; y: Int32; z: Int32) :=
z_WindowPos3iARB_ovr_0(x, y, z);
private static procedure z_WindowPos3ivARB_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glWindowPos3ivARB';
private static procedure z_WindowPos3ivARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3ivARB_ovr_0(v[0]) else
z_WindowPos3ivARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(var v: Int32) :=
z_WindowPos3ivARB_ovr_0(v);
private static procedure z_WindowPos3ivARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3ivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(v: IntPtr) :=
z_WindowPos3ivARB_ovr_2(v);
private static procedure z_WindowPos3sARB_ovr_0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glWindowPos3sARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sARB(x: Int16; y: Int16; z: Int16) :=
z_WindowPos3sARB_ovr_0(x, y, z);
private static procedure z_WindowPos3svARB_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glWindowPos3svARB';
private static procedure z_WindowPos3svARB_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3svARB_ovr_0(v[0]) else
z_WindowPos3svARB_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(var v: Int16) :=
z_WindowPos3svARB_ovr_0(v);
private static procedure z_WindowPos3svARB_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3svARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(v: IntPtr) :=
z_WindowPos3svARB_ovr_2(v);
end;
[PCUNotRestore]
glDrawBuffersATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawBuffersATI_ovr_0(n: Int32; var bufs: DrawBufferMode);
external 'opengl32.dll' name 'glDrawBuffersATI';
private static procedure z_DrawBuffersATI_ovr_0_anh001(n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glDrawBuffersATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; bufs: array of DrawBufferMode) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_DrawBuffersATI_ovr_0(n, bufs[0]) else
z_DrawBuffersATI_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; var bufs: DrawBufferMode) :=
z_DrawBuffersATI_ovr_0(n, bufs);
private static procedure z_DrawBuffersATI_ovr_2(n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glDrawBuffersATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; bufs: IntPtr) :=
z_DrawBuffersATI_ovr_2(n, bufs);
end;
[PCUNotRestore]
glElementArrayATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ElementPointerATI_ovr_0(&type: ElementPointerTypeATI; pointer: IntPtr);
external 'opengl32.dll' name 'glElementPointerATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ElementPointerATI(&type: ElementPointerTypeATI; pointer: IntPtr) :=
z_ElementPointerATI_ovr_0(&type, pointer);
private static procedure z_DrawElementArrayATI_ovr_0(mode: PrimitiveType; count: Int32);
external 'opengl32.dll' name 'glDrawElementArrayATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementArrayATI(mode: PrimitiveType; count: Int32) :=
z_DrawElementArrayATI_ovr_0(mode, count);
private static procedure z_DrawRangeElementArrayATI_ovr_0(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32);
external 'opengl32.dll' name 'glDrawRangeElementArrayATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementArrayATI(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32) :=
z_DrawRangeElementArrayATI_ovr_0(mode, start, &end, count);
end;
[PCUNotRestore]
glEnvmapBumpmapATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexBumpParameterivATI_ovr_0(pname: TexBumpParameterATI; var param: Int32);
external 'opengl32.dll' name 'glTexBumpParameterivATI';
private static procedure z_TexBumpParameterivATI_ovr_0_anh001(pname: TexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glTexBumpParameterivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: TexBumpParameterATI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_TexBumpParameterivATI_ovr_0(pname, param[0]) else
z_TexBumpParameterivATI_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: TexBumpParameterATI; var param: Int32) :=
z_TexBumpParameterivATI_ovr_0(pname, param);
private static procedure z_TexBumpParameterivATI_ovr_2(pname: TexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glTexBumpParameterivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: TexBumpParameterATI; param: IntPtr) :=
z_TexBumpParameterivATI_ovr_2(pname, param);
private static procedure z_TexBumpParameterfvATI_ovr_0(pname: TexBumpParameterATI; var param: single);
external 'opengl32.dll' name 'glTexBumpParameterfvATI';
private static procedure z_TexBumpParameterfvATI_ovr_0_anh001(pname: TexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glTexBumpParameterfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: TexBumpParameterATI; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_TexBumpParameterfvATI_ovr_0(pname, param[0]) else
z_TexBumpParameterfvATI_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: TexBumpParameterATI; var param: single) :=
z_TexBumpParameterfvATI_ovr_0(pname, param);
private static procedure z_TexBumpParameterfvATI_ovr_2(pname: TexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glTexBumpParameterfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: TexBumpParameterATI; param: IntPtr) :=
z_TexBumpParameterfvATI_ovr_2(pname, param);
private static procedure z_GetTexBumpParameterivATI_ovr_0(pname: GetTexBumpParameterATI; var param: Int32);
external 'opengl32.dll' name 'glGetTexBumpParameterivATI';
private static procedure z_GetTexBumpParameterivATI_ovr_0_anh001(pname: GetTexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glGetTexBumpParameterivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetTexBumpParameterivATI_ovr_0(pname, param[0]) else
z_GetTexBumpParameterivATI_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; var param: Int32) :=
z_GetTexBumpParameterivATI_ovr_0(pname, param);
private static procedure z_GetTexBumpParameterivATI_ovr_2(pname: GetTexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glGetTexBumpParameterivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; param: IntPtr) :=
z_GetTexBumpParameterivATI_ovr_2(pname, param);
private static procedure z_GetTexBumpParameterfvATI_ovr_0(pname: GetTexBumpParameterATI; var param: single);
external 'opengl32.dll' name 'glGetTexBumpParameterfvATI';
private static procedure z_GetTexBumpParameterfvATI_ovr_0_anh001(pname: GetTexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glGetTexBumpParameterfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; param: array of single) :=
if (param<>nil) and (param.Length<>0) then
z_GetTexBumpParameterfvATI_ovr_0(pname, param[0]) else
z_GetTexBumpParameterfvATI_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; var param: single) :=
z_GetTexBumpParameterfvATI_ovr_0(pname, param);
private static procedure z_GetTexBumpParameterfvATI_ovr_2(pname: GetTexBumpParameterATI; param: IntPtr);
external 'opengl32.dll' name 'glGetTexBumpParameterfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; param: IntPtr) :=
z_GetTexBumpParameterfvATI_ovr_2(pname, param);
end;
[PCUNotRestore]
glFragmentShaderATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GenFragmentShadersATI_ovr_0(range: UInt32): UInt32;
external 'opengl32.dll' name 'glGenFragmentShadersATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenFragmentShadersATI(range: UInt32): UInt32 :=
z_GenFragmentShadersATI_ovr_0(range);
private static procedure z_BindFragmentShaderATI_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glBindFragmentShaderATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragmentShaderATI(id: UInt32) :=
z_BindFragmentShaderATI_ovr_0(id);
private static procedure z_DeleteFragmentShaderATI_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glDeleteFragmentShaderATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFragmentShaderATI(id: UInt32) :=
z_DeleteFragmentShaderATI_ovr_0(id);
private static procedure z_BeginFragmentShaderATI_ovr_0;
external 'opengl32.dll' name 'glBeginFragmentShaderATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginFragmentShaderATI :=
z_BeginFragmentShaderATI_ovr_0;
private static procedure z_EndFragmentShaderATI_ovr_0;
external 'opengl32.dll' name 'glEndFragmentShaderATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndFragmentShaderATI :=
z_EndFragmentShaderATI_ovr_0;
private static procedure z_PassTexCoordATI_ovr_0(dst: UInt32; coord: UInt32; swizzle: SwizzleOpATI);
external 'opengl32.dll' name 'glPassTexCoordATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassTexCoordATI(dst: UInt32; coord: UInt32; swizzle: SwizzleOpATI) :=
z_PassTexCoordATI_ovr_0(dst, coord, swizzle);
private static procedure z_SampleMapATI_ovr_0(dst: UInt32; interp: UInt32; swizzle: SwizzleOpATI);
external 'opengl32.dll' name 'glSampleMapATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMapATI(dst: UInt32; interp: UInt32; swizzle: SwizzleOpATI) :=
z_SampleMapATI_ovr_0(dst, interp, swizzle);
private static procedure z_ColorFragmentOp1ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32);
external 'opengl32.dll' name 'glColorFragmentOp1ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFragmentOp1ATI(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32) :=
z_ColorFragmentOp1ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
private static procedure z_ColorFragmentOp2ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32);
external 'opengl32.dll' name 'glColorFragmentOp2ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFragmentOp2ATI(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32) :=
z_ColorFragmentOp2ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
private static procedure z_ColorFragmentOp3ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32; arg3: UInt32; arg3Rep: UInt32; arg3Mod: UInt32);
external 'opengl32.dll' name 'glColorFragmentOp3ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFragmentOp3ATI(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32; arg3: UInt32; arg3Rep: UInt32; arg3Mod: UInt32) :=
z_ColorFragmentOp3ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
private static procedure z_AlphaFragmentOp1ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32);
external 'opengl32.dll' name 'glAlphaFragmentOp1ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFragmentOp1ATI(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32) :=
z_AlphaFragmentOp1ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
private static procedure z_AlphaFragmentOp2ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32);
external 'opengl32.dll' name 'glAlphaFragmentOp2ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFragmentOp2ATI(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32) :=
z_AlphaFragmentOp2ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
private static procedure z_AlphaFragmentOp3ATI_ovr_0(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32; arg3: UInt32; arg3Rep: UInt32; arg3Mod: UInt32);
external 'opengl32.dll' name 'glAlphaFragmentOp3ATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFragmentOp3ATI(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32; arg3: UInt32; arg3Rep: UInt32; arg3Mod: UInt32) :=
z_AlphaFragmentOp3ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
private static procedure z_SetFragmentShaderConstantATI_ovr_0(dst: UInt32; var value: single);
external 'opengl32.dll' name 'glSetFragmentShaderConstantATI';
private static procedure z_SetFragmentShaderConstantATI_ovr_0_anh001(dst: UInt32; value: IntPtr);
external 'opengl32.dll' name 'glSetFragmentShaderConstantATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_SetFragmentShaderConstantATI_ovr_0(dst, value[0]) else
z_SetFragmentShaderConstantATI_ovr_0_anh001(dst, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; var value: single) :=
z_SetFragmentShaderConstantATI_ovr_0(dst, value);
private static procedure z_SetFragmentShaderConstantATI_ovr_2(dst: UInt32; value: IntPtr);
external 'opengl32.dll' name 'glSetFragmentShaderConstantATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; value: IntPtr) :=
z_SetFragmentShaderConstantATI_ovr_2(dst, value);
end;
[PCUNotRestore]
glMapObjectBufferATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_MapObjectBufferATI_ovr_0(buffer: UInt32): IntPtr;
external 'opengl32.dll' name 'glMapObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapObjectBufferATI(buffer: UInt32): IntPtr :=
z_MapObjectBufferATI_ovr_0(buffer);
private static procedure z_UnmapObjectBufferATI_ovr_0(buffer: UInt32);
external 'opengl32.dll' name 'glUnmapObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnmapObjectBufferATI(buffer: UInt32) :=
z_UnmapObjectBufferATI_ovr_0(buffer);
end;
[PCUNotRestore]
glPnTrianglesATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PNTrianglesiATI_ovr_0(pname: PNTrianglesPNameATI; param: Int32);
external 'opengl32.dll' name 'glPNTrianglesiATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PNTrianglesiATI(pname: PNTrianglesPNameATI; param: Int32) :=
z_PNTrianglesiATI_ovr_0(pname, param);
private static procedure z_PNTrianglesfATI_ovr_0(pname: PNTrianglesPNameATI; param: single);
external 'opengl32.dll' name 'glPNTrianglesfATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PNTrianglesfATI(pname: PNTrianglesPNameATI; param: single) :=
z_PNTrianglesfATI_ovr_0(pname, param);
end;
[PCUNotRestore]
glSeparateStencilATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_StencilOpSeparateATI_ovr_0(face: StencilFaceDirection; sfail: StencilOp; dpfail: StencilOp; dppass: StencilOp);
external 'opengl32.dll' name 'glStencilOpSeparateATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOpSeparateATI(face: StencilFaceDirection; sfail: StencilOp; dpfail: StencilOp; dppass: StencilOp) :=
z_StencilOpSeparateATI_ovr_0(face, sfail, dpfail, dppass);
private static procedure z_StencilFuncSeparateATI_ovr_0(frontfunc: StencilFunction; backfunc: StencilFunction; ref: Int32; mask: UInt32);
external 'opengl32.dll' name 'glStencilFuncSeparateATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFuncSeparateATI(frontfunc: StencilFunction; backfunc: StencilFunction; ref: Int32; mask: UInt32) :=
z_StencilFuncSeparateATI_ovr_0(frontfunc, backfunc, ref, mask);
end;
[PCUNotRestore]
glVertexArrayObjectATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_NewObjectBufferATI_ovr_0(size: Int32; pointer: IntPtr; usage: ArrayObjectUsageATI): UInt32;
external 'opengl32.dll' name 'glNewObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function NewObjectBufferATI(size: Int32; pointer: IntPtr; usage: ArrayObjectUsageATI): UInt32 :=
z_NewObjectBufferATI_ovr_0(size, pointer, usage);
private static function z_IsObjectBufferATI_ovr_0(buffer: UInt32): boolean;
external 'opengl32.dll' name 'glIsObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsObjectBufferATI(buffer: UInt32): boolean :=
z_IsObjectBufferATI_ovr_0(buffer);
private static procedure z_UpdateObjectBufferATI_ovr_0(buffer: UInt32; offset: UInt32; size: Int32; pointer: IntPtr; preserve: PreserveModeATI);
external 'opengl32.dll' name 'glUpdateObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UpdateObjectBufferATI(buffer: UInt32; offset: UInt32; size: Int32; pointer: IntPtr; preserve: PreserveModeATI) :=
z_UpdateObjectBufferATI_ovr_0(buffer, offset, size, pointer, preserve);
private static procedure z_GetObjectBufferfvATI_ovr_0(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
external 'opengl32.dll' name 'glGetObjectBufferfvATI';
private static procedure z_GetObjectBufferfvATI_ovr_0_anh0001(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectBufferfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetObjectBufferfvATI_ovr_0(buffer, pname, ¶ms[0]) else
z_GetObjectBufferfvATI_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single) :=
z_GetObjectBufferfvATI_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetObjectBufferfvATI_ovr_2(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectBufferfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetObjectBufferfvATI_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetObjectBufferivATI_ovr_0(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetObjectBufferivATI';
private static procedure z_GetObjectBufferivATI_ovr_0_anh0001(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectBufferivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetObjectBufferivATI_ovr_0(buffer, pname, ¶ms[0]) else
z_GetObjectBufferivATI_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32) :=
z_GetObjectBufferivATI_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetObjectBufferivATI_ovr_2(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetObjectBufferivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetObjectBufferivATI_ovr_2(buffer, pname, ¶ms);
private static procedure z_FreeObjectBufferATI_ovr_0(buffer: UInt32);
external 'opengl32.dll' name 'glFreeObjectBufferATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FreeObjectBufferATI(buffer: UInt32) :=
z_FreeObjectBufferATI_ovr_0(buffer);
private static procedure z_ArrayObjectATI_ovr_0(&array: EnableCap; size: Int32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32);
external 'opengl32.dll' name 'glArrayObjectATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayObjectATI(&array: EnableCap; size: Int32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32) :=
z_ArrayObjectATI_ovr_0(&array, size, &type, stride, buffer, offset);
private static procedure z_GetArrayObjectfvATI_ovr_0(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: single);
external 'opengl32.dll' name 'glGetArrayObjectfvATI';
private static procedure z_GetArrayObjectfvATI_ovr_0_anh0001(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetArrayObjectfvATI_ovr_0(&array, pname, ¶ms[0]) else
z_GetArrayObjectfvATI_ovr_0_anh0001(&array, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: single) :=
z_GetArrayObjectfvATI_ovr_0(&array, pname, ¶ms);
private static procedure z_GetArrayObjectfvATI_ovr_2(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetArrayObjectfvATI_ovr_2(&array, pname, ¶ms);
private static procedure z_GetArrayObjectivATI_ovr_0(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetArrayObjectivATI';
private static procedure z_GetArrayObjectivATI_ovr_0_anh0001(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetArrayObjectivATI_ovr_0(&array, pname, ¶ms[0]) else
z_GetArrayObjectivATI_ovr_0_anh0001(&array, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: Int32) :=
z_GetArrayObjectivATI_ovr_0(&array, pname, ¶ms);
private static procedure z_GetArrayObjectivATI_ovr_2(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetArrayObjectivATI_ovr_2(&array, pname, ¶ms);
private static procedure z_VariantArrayObjectATI_ovr_0(id: UInt32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32);
external 'opengl32.dll' name 'glVariantArrayObjectATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantArrayObjectATI(id: UInt32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32) :=
z_VariantArrayObjectATI_ovr_0(id, &type, stride, buffer, offset);
private static procedure z_GetVariantArrayObjectfvATI_ovr_0(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
external 'opengl32.dll' name 'glGetVariantArrayObjectfvATI';
private static procedure z_GetVariantArrayObjectfvATI_ovr_0_anh0001(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVariantArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVariantArrayObjectfvATI_ovr_0(id, pname, ¶ms[0]) else
z_GetVariantArrayObjectfvATI_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single) :=
z_GetVariantArrayObjectfvATI_ovr_0(id, pname, ¶ms);
private static procedure z_GetVariantArrayObjectfvATI_ovr_2(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVariantArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetVariantArrayObjectfvATI_ovr_2(id, pname, ¶ms);
private static procedure z_GetVariantArrayObjectivATI_ovr_0(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVariantArrayObjectivATI';
private static procedure z_GetVariantArrayObjectivATI_ovr_0_anh0001(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVariantArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVariantArrayObjectivATI_ovr_0(id, pname, ¶ms[0]) else
z_GetVariantArrayObjectivATI_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32) :=
z_GetVariantArrayObjectivATI_ovr_0(id, pname, ¶ms);
private static procedure z_GetVariantArrayObjectivATI_ovr_2(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVariantArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetVariantArrayObjectivATI_ovr_2(id, pname, ¶ms);
end;
[PCUNotRestore]
glVertexAttribArrayObjectATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribArrayObjectATI_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; buffer: UInt32; offset: UInt32);
external 'opengl32.dll' name 'glVertexAttribArrayObjectATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribArrayObjectATI(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; buffer: UInt32; offset: UInt32) :=
z_VertexAttribArrayObjectATI_ovr_0(index, size, &type, normalized, stride, buffer, offset);
private static procedure z_GetVertexAttribArrayObjectfvATI_ovr_0(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectfvATI';
private static procedure z_GetVertexAttribArrayObjectfvATI_ovr_0_anh0001(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribArrayObjectfvATI_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribArrayObjectfvATI_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single) :=
z_GetVertexAttribArrayObjectfvATI_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribArrayObjectfvATI_ovr_2(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectfvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetVertexAttribArrayObjectfvATI_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribArrayObjectivATI_ovr_0(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectivATI';
private static procedure z_GetVertexAttribArrayObjectivATI_ovr_0_anh0001(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribArrayObjectivATI_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribArrayObjectivATI_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32) :=
z_GetVertexAttribArrayObjectivATI_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribArrayObjectivATI_ovr_2(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribArrayObjectivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr) :=
z_GetVertexAttribArrayObjectivATI_ovr_2(index, pname, ¶ms);
end;
[PCUNotRestore]
glVertexStreamsATI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexStream1sATI_ovr_0(stream: VertexStreamATI; x: Int16);
external 'opengl32.dll' name 'glVertexStream1sATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1sATI(stream: VertexStreamATI; x: Int16) :=
z_VertexStream1sATI_ovr_0(stream, x);
private static procedure z_VertexStream1svATI_ovr_0(stream: VertexStreamATI; var coords: Int16);
external 'opengl32.dll' name 'glVertexStream1svATI';
private static procedure z_VertexStream1svATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; coords: array of Int16) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream1svATI_ovr_0(stream, coords[0]) else
z_VertexStream1svATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; var coords: Int16) :=
z_VertexStream1svATI_ovr_0(stream, coords);
private static procedure z_VertexStream1svATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream1svATI_ovr_2(stream, coords);
private static procedure z_VertexStream1iATI_ovr_0(stream: VertexStreamATI; x: Int32);
external 'opengl32.dll' name 'glVertexStream1iATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1iATI(stream: VertexStreamATI; x: Int32) :=
z_VertexStream1iATI_ovr_0(stream, x);
private static procedure z_VertexStream1ivATI_ovr_0(stream: VertexStreamATI; var coords: Int32);
external 'opengl32.dll' name 'glVertexStream1ivATI';
private static procedure z_VertexStream1ivATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; coords: array of Int32) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream1ivATI_ovr_0(stream, coords[0]) else
z_VertexStream1ivATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; var coords: Int32) :=
z_VertexStream1ivATI_ovr_0(stream, coords);
private static procedure z_VertexStream1ivATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream1ivATI_ovr_2(stream, coords);
private static procedure z_VertexStream1fATI_ovr_0(stream: VertexStreamATI; x: single);
external 'opengl32.dll' name 'glVertexStream1fATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fATI(stream: VertexStreamATI; x: single) :=
z_VertexStream1fATI_ovr_0(stream, x);
private static procedure z_VertexStream1fvATI_ovr_0(stream: VertexStreamATI; var coords: single);
external 'opengl32.dll' name 'glVertexStream1fvATI';
private static procedure z_VertexStream1fvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream1fvATI_ovr_0(stream, coords[0]) else
z_VertexStream1fvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; var coords: single) :=
z_VertexStream1fvATI_ovr_0(stream, coords);
private static procedure z_VertexStream1fvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream1fvATI_ovr_2(stream, coords);
private static procedure z_VertexStream1dATI_ovr_0(stream: VertexStreamATI; x: real);
external 'opengl32.dll' name 'glVertexStream1dATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dATI(stream: VertexStreamATI; x: real) :=
z_VertexStream1dATI_ovr_0(stream, x);
private static procedure z_VertexStream1dvATI_ovr_0(stream: VertexStreamATI; var coords: real);
external 'opengl32.dll' name 'glVertexStream1dvATI';
private static procedure z_VertexStream1dvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; coords: array of real) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream1dvATI_ovr_0(stream, coords[0]) else
z_VertexStream1dvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; var coords: real) :=
z_VertexStream1dvATI_ovr_0(stream, coords);
private static procedure z_VertexStream1dvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream1dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream1dvATI_ovr_2(stream, coords);
private static procedure z_VertexStream2sATI_ovr_0(stream: VertexStreamATI; x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertexStream2sATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2sATI(stream: VertexStreamATI; x: Int16; y: Int16) :=
z_VertexStream2sATI_ovr_0(stream, x, y);
private static procedure z_VertexStream2svATI_ovr_0(stream: VertexStreamATI; var coords: Int16);
external 'opengl32.dll' name 'glVertexStream2svATI';
private static procedure z_VertexStream2svATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; coords: array of Int16) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream2svATI_ovr_0(stream, coords[0]) else
z_VertexStream2svATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; var coords: Int16) :=
z_VertexStream2svATI_ovr_0(stream, coords);
private static procedure z_VertexStream2svATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream2svATI_ovr_2(stream, coords);
private static procedure z_VertexStream2iATI_ovr_0(stream: VertexStreamATI; x: Int32; y: Int32);
external 'opengl32.dll' name 'glVertexStream2iATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2iATI(stream: VertexStreamATI; x: Int32; y: Int32) :=
z_VertexStream2iATI_ovr_0(stream, x, y);
private static procedure z_VertexStream2ivATI_ovr_0(stream: VertexStreamATI; var coords: Int32);
external 'opengl32.dll' name 'glVertexStream2ivATI';
private static procedure z_VertexStream2ivATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; coords: array of Int32) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream2ivATI_ovr_0(stream, coords[0]) else
z_VertexStream2ivATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; var coords: Int32) :=
z_VertexStream2ivATI_ovr_0(stream, coords);
private static procedure z_VertexStream2ivATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream2ivATI_ovr_2(stream, coords);
private static procedure z_VertexStream2fATI_ovr_0(stream: VertexStreamATI; x: single; y: single);
external 'opengl32.dll' name 'glVertexStream2fATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fATI(stream: VertexStreamATI; x: single; y: single) :=
z_VertexStream2fATI_ovr_0(stream, x, y);
private static procedure z_VertexStream2fvATI_ovr_0(stream: VertexStreamATI; var coords: single);
external 'opengl32.dll' name 'glVertexStream2fvATI';
private static procedure z_VertexStream2fvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream2fvATI_ovr_0(stream, coords[0]) else
z_VertexStream2fvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; var coords: single) :=
z_VertexStream2fvATI_ovr_0(stream, coords);
private static procedure z_VertexStream2fvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream2fvATI_ovr_2(stream, coords);
private static procedure z_VertexStream2dATI_ovr_0(stream: VertexStreamATI; x: real; y: real);
external 'opengl32.dll' name 'glVertexStream2dATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dATI(stream: VertexStreamATI; x: real; y: real) :=
z_VertexStream2dATI_ovr_0(stream, x, y);
private static procedure z_VertexStream2dvATI_ovr_0(stream: VertexStreamATI; var coords: real);
external 'opengl32.dll' name 'glVertexStream2dvATI';
private static procedure z_VertexStream2dvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; coords: array of real) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream2dvATI_ovr_0(stream, coords[0]) else
z_VertexStream2dvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; var coords: real) :=
z_VertexStream2dvATI_ovr_0(stream, coords);
private static procedure z_VertexStream2dvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream2dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream2dvATI_ovr_2(stream, coords);
private static procedure z_VertexStream3sATI_ovr_0(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertexStream3sATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3sATI(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16) :=
z_VertexStream3sATI_ovr_0(stream, x, y, z);
private static procedure z_VertexStream3svATI_ovr_0(stream: VertexStreamATI; var coords: Int16);
external 'opengl32.dll' name 'glVertexStream3svATI';
private static procedure z_VertexStream3svATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; coords: array of Int16) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream3svATI_ovr_0(stream, coords[0]) else
z_VertexStream3svATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; var coords: Int16) :=
z_VertexStream3svATI_ovr_0(stream, coords);
private static procedure z_VertexStream3svATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream3svATI_ovr_2(stream, coords);
private static procedure z_VertexStream3iATI_ovr_0(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glVertexStream3iATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3iATI(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32) :=
z_VertexStream3iATI_ovr_0(stream, x, y, z);
private static procedure z_VertexStream3ivATI_ovr_0(stream: VertexStreamATI; var coords: Int32);
external 'opengl32.dll' name 'glVertexStream3ivATI';
private static procedure z_VertexStream3ivATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; coords: array of Int32) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream3ivATI_ovr_0(stream, coords[0]) else
z_VertexStream3ivATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; var coords: Int32) :=
z_VertexStream3ivATI_ovr_0(stream, coords);
private static procedure z_VertexStream3ivATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream3ivATI_ovr_2(stream, coords);
private static procedure z_VertexStream3fATI_ovr_0(stream: VertexStreamATI; x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertexStream3fATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fATI(stream: VertexStreamATI; x: single; y: single; z: single) :=
z_VertexStream3fATI_ovr_0(stream, x, y, z);
private static procedure z_VertexStream3fvATI_ovr_0(stream: VertexStreamATI; var coords: single);
external 'opengl32.dll' name 'glVertexStream3fvATI';
private static procedure z_VertexStream3fvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream3fvATI_ovr_0(stream, coords[0]) else
z_VertexStream3fvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; var coords: single) :=
z_VertexStream3fvATI_ovr_0(stream, coords);
private static procedure z_VertexStream3fvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream3fvATI_ovr_2(stream, coords);
private static procedure z_VertexStream3dATI_ovr_0(stream: VertexStreamATI; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexStream3dATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dATI(stream: VertexStreamATI; x: real; y: real; z: real) :=
z_VertexStream3dATI_ovr_0(stream, x, y, z);
private static procedure z_VertexStream3dvATI_ovr_0(stream: VertexStreamATI; var coords: real);
external 'opengl32.dll' name 'glVertexStream3dvATI';
private static procedure z_VertexStream3dvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; coords: array of real) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream3dvATI_ovr_0(stream, coords[0]) else
z_VertexStream3dvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; var coords: real) :=
z_VertexStream3dvATI_ovr_0(stream, coords);
private static procedure z_VertexStream3dvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream3dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream3dvATI_ovr_2(stream, coords);
private static procedure z_VertexStream4sATI_ovr_0(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertexStream4sATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4sATI(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16; w: Int16) :=
z_VertexStream4sATI_ovr_0(stream, x, y, z, w);
private static procedure z_VertexStream4svATI_ovr_0(stream: VertexStreamATI; var coords: Int16);
external 'opengl32.dll' name 'glVertexStream4svATI';
private static procedure z_VertexStream4svATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; coords: array of Int16) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream4svATI_ovr_0(stream, coords[0]) else
z_VertexStream4svATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; var coords: Int16) :=
z_VertexStream4svATI_ovr_0(stream, coords);
private static procedure z_VertexStream4svATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream4svATI_ovr_2(stream, coords);
private static procedure z_VertexStream4iATI_ovr_0(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glVertexStream4iATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4iATI(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_VertexStream4iATI_ovr_0(stream, x, y, z, w);
private static procedure z_VertexStream4ivATI_ovr_0(stream: VertexStreamATI; var coords: Int32);
external 'opengl32.dll' name 'glVertexStream4ivATI';
private static procedure z_VertexStream4ivATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; coords: array of Int32) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream4ivATI_ovr_0(stream, coords[0]) else
z_VertexStream4ivATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; var coords: Int32) :=
z_VertexStream4ivATI_ovr_0(stream, coords);
private static procedure z_VertexStream4ivATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream4ivATI_ovr_2(stream, coords);
private static procedure z_VertexStream4fATI_ovr_0(stream: VertexStreamATI; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertexStream4fATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fATI(stream: VertexStreamATI; x: single; y: single; z: single; w: single) :=
z_VertexStream4fATI_ovr_0(stream, x, y, z, w);
private static procedure z_VertexStream4fvATI_ovr_0(stream: VertexStreamATI; var coords: single);
external 'opengl32.dll' name 'glVertexStream4fvATI';
private static procedure z_VertexStream4fvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream4fvATI_ovr_0(stream, coords[0]) else
z_VertexStream4fvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; var coords: single) :=
z_VertexStream4fvATI_ovr_0(stream, coords);
private static procedure z_VertexStream4fvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream4fvATI_ovr_2(stream, coords);
private static procedure z_VertexStream4dATI_ovr_0(stream: VertexStreamATI; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexStream4dATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dATI(stream: VertexStreamATI; x: real; y: real; z: real; w: real) :=
z_VertexStream4dATI_ovr_0(stream, x, y, z, w);
private static procedure z_VertexStream4dvATI_ovr_0(stream: VertexStreamATI; var coords: real);
external 'opengl32.dll' name 'glVertexStream4dvATI';
private static procedure z_VertexStream4dvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; coords: array of real) :=
if (coords<>nil) and (coords.Length<>0) then
z_VertexStream4dvATI_ovr_0(stream, coords[0]) else
z_VertexStream4dvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; var coords: real) :=
z_VertexStream4dvATI_ovr_0(stream, coords);
private static procedure z_VertexStream4dvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glVertexStream4dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_VertexStream4dvATI_ovr_2(stream, coords);
private static procedure z_NormalStream3bATI_ovr_0(stream: VertexStreamATI; nx: SByte; ny: SByte; nz: SByte);
external 'opengl32.dll' name 'glNormalStream3bATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bATI(stream: VertexStreamATI; nx: SByte; ny: SByte; nz: SByte) :=
z_NormalStream3bATI_ovr_0(stream, nx, ny, nz);
private static procedure z_NormalStream3bvATI_ovr_0(stream: VertexStreamATI; var coords: SByte);
external 'opengl32.dll' name 'glNormalStream3bvATI';
private static procedure z_NormalStream3bvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3bvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalStream3bvATI_ovr_0(stream, coords[0]) else
z_NormalStream3bvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; var coords: SByte) :=
z_NormalStream3bvATI_ovr_0(stream, coords);
private static procedure z_NormalStream3bvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3bvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_NormalStream3bvATI_ovr_2(stream, coords);
private static procedure z_NormalStream3sATI_ovr_0(stream: VertexStreamATI; nx: Int16; ny: Int16; nz: Int16);
external 'opengl32.dll' name 'glNormalStream3sATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3sATI(stream: VertexStreamATI; nx: Int16; ny: Int16; nz: Int16) :=
z_NormalStream3sATI_ovr_0(stream, nx, ny, nz);
private static procedure z_NormalStream3svATI_ovr_0(stream: VertexStreamATI; var coords: Int16);
external 'opengl32.dll' name 'glNormalStream3svATI';
private static procedure z_NormalStream3svATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; coords: array of Int16) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalStream3svATI_ovr_0(stream, coords[0]) else
z_NormalStream3svATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; var coords: Int16) :=
z_NormalStream3svATI_ovr_0(stream, coords);
private static procedure z_NormalStream3svATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3svATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; coords: IntPtr) :=
z_NormalStream3svATI_ovr_2(stream, coords);
private static procedure z_NormalStream3iATI_ovr_0(stream: VertexStreamATI; nx: Int32; ny: Int32; nz: Int32);
external 'opengl32.dll' name 'glNormalStream3iATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3iATI(stream: VertexStreamATI; nx: Int32; ny: Int32; nz: Int32) :=
z_NormalStream3iATI_ovr_0(stream, nx, ny, nz);
private static procedure z_NormalStream3ivATI_ovr_0(stream: VertexStreamATI; var coords: Int32);
external 'opengl32.dll' name 'glNormalStream3ivATI';
private static procedure z_NormalStream3ivATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; coords: array of Int32) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalStream3ivATI_ovr_0(stream, coords[0]) else
z_NormalStream3ivATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; var coords: Int32) :=
z_NormalStream3ivATI_ovr_0(stream, coords);
private static procedure z_NormalStream3ivATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3ivATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; coords: IntPtr) :=
z_NormalStream3ivATI_ovr_2(stream, coords);
private static procedure z_NormalStream3fATI_ovr_0(stream: VertexStreamATI; nx: single; ny: single; nz: single);
external 'opengl32.dll' name 'glNormalStream3fATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fATI(stream: VertexStreamATI; nx: single; ny: single; nz: single) :=
z_NormalStream3fATI_ovr_0(stream, nx, ny, nz);
private static procedure z_NormalStream3fvATI_ovr_0(stream: VertexStreamATI; var coords: single);
external 'opengl32.dll' name 'glNormalStream3fvATI';
private static procedure z_NormalStream3fvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalStream3fvATI_ovr_0(stream, coords[0]) else
z_NormalStream3fvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; var coords: single) :=
z_NormalStream3fvATI_ovr_0(stream, coords);
private static procedure z_NormalStream3fvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3fvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_NormalStream3fvATI_ovr_2(stream, coords);
private static procedure z_NormalStream3dATI_ovr_0(stream: VertexStreamATI; nx: real; ny: real; nz: real);
external 'opengl32.dll' name 'glNormalStream3dATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dATI(stream: VertexStreamATI; nx: real; ny: real; nz: real) :=
z_NormalStream3dATI_ovr_0(stream, nx, ny, nz);
private static procedure z_NormalStream3dvATI_ovr_0(stream: VertexStreamATI; var coords: real);
external 'opengl32.dll' name 'glNormalStream3dvATI';
private static procedure z_NormalStream3dvATI_ovr_0_anh001(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; coords: array of real) :=
if (coords<>nil) and (coords.Length<>0) then
z_NormalStream3dvATI_ovr_0(stream, coords[0]) else
z_NormalStream3dvATI_ovr_0_anh001(stream, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; var coords: real) :=
z_NormalStream3dvATI_ovr_0(stream, coords);
private static procedure z_NormalStream3dvATI_ovr_2(stream: VertexStreamATI; coords: IntPtr);
external 'opengl32.dll' name 'glNormalStream3dvATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; coords: IntPtr) :=
z_NormalStream3dvATI_ovr_2(stream, coords);
private static procedure z_ClientActiveVertexStreamATI_ovr_0(stream: VertexStreamATI);
external 'opengl32.dll' name 'glClientActiveVertexStreamATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveVertexStreamATI(stream: VertexStreamATI) :=
z_ClientActiveVertexStreamATI_ovr_0(stream);
private static procedure z_VertexBlendEnviATI_ovr_0(pname: VertexStreamATI; param: Int32);
external 'opengl32.dll' name 'glVertexBlendEnviATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendEnviATI(pname: VertexStreamATI; param: Int32) :=
z_VertexBlendEnviATI_ovr_0(pname, param);
private static procedure z_VertexBlendEnvfATI_ovr_0(pname: VertexStreamATI; param: single);
external 'opengl32.dll' name 'glVertexBlendEnvfATI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendEnvfATI(pname: VertexStreamATI; param: single) :=
z_VertexBlendEnvfATI_ovr_0(pname, param);
end;
[PCUNotRestore]
glEGLImageStorageEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_EGLImageTargetTexStorageEXT_ovr_0(target: DummyEnum; image: GLeglImageOES; var attrib_list: Int32);
external 'opengl32.dll' name 'glEGLImageTargetTexStorageEXT';
private static procedure z_EGLImageTargetTexStorageEXT_ovr_0_anh0001(target: DummyEnum; image: GLeglImageOES; attrib_list: IntPtr);
external 'opengl32.dll' name 'glEGLImageTargetTexStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; attrib_list: array of Int32) :=
if (attrib_list<>nil) and (attrib_list.Length<>0) then
z_EGLImageTargetTexStorageEXT_ovr_0(target, image, attrib_list[0]) else
z_EGLImageTargetTexStorageEXT_ovr_0_anh0001(target, image, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; var attrib_list: Int32) :=
z_EGLImageTargetTexStorageEXT_ovr_0(target, image, attrib_list);
private static procedure z_EGLImageTargetTexStorageEXT_ovr_2(target: DummyEnum; image: GLeglImageOES; attrib_list: IntPtr);
external 'opengl32.dll' name 'glEGLImageTargetTexStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; attrib_list: IntPtr) :=
z_EGLImageTargetTexStorageEXT_ovr_2(target, image, attrib_list);
private static procedure z_EGLImageTargetTextureStorageEXT_ovr_0(texture: UInt32; image: GLeglImageOES; var attrib_list: Int32);
external 'opengl32.dll' name 'glEGLImageTargetTextureStorageEXT';
private static procedure z_EGLImageTargetTextureStorageEXT_ovr_0_anh0001(texture: UInt32; image: GLeglImageOES; attrib_list: IntPtr);
external 'opengl32.dll' name 'glEGLImageTargetTextureStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; attrib_list: array of Int32) :=
if (attrib_list<>nil) and (attrib_list.Length<>0) then
z_EGLImageTargetTextureStorageEXT_ovr_0(texture, image, attrib_list[0]) else
z_EGLImageTargetTextureStorageEXT_ovr_0_anh0001(texture, image, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; var attrib_list: Int32) :=
z_EGLImageTargetTextureStorageEXT_ovr_0(texture, image, attrib_list);
private static procedure z_EGLImageTargetTextureStorageEXT_ovr_2(texture: UInt32; image: GLeglImageOES; attrib_list: IntPtr);
external 'opengl32.dll' name 'glEGLImageTargetTextureStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; attrib_list: IntPtr) :=
z_EGLImageTargetTextureStorageEXT_ovr_2(texture, image, attrib_list);
end;
[PCUNotRestore]
glBindableUniformEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_UniformBufferEXT_ovr_0(&program: UInt32; location: Int32; buffer: UInt32);
external 'opengl32.dll' name 'glUniformBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformBufferEXT(&program: UInt32; location: Int32; buffer: UInt32) :=
z_UniformBufferEXT_ovr_0(&program, location, buffer);
private static function z_GetUniformBufferSizeEXT_ovr_0(&program: UInt32; location: Int32): Int32;
external 'opengl32.dll' name 'glGetUniformBufferSizeEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBufferSizeEXT(&program: UInt32; location: Int32): Int32 :=
z_GetUniformBufferSizeEXT_ovr_0(&program, location);
private static function z_GetUniformOffsetEXT_ovr_0(&program: UInt32; location: Int32): IntPtr;
external 'opengl32.dll' name 'glGetUniformOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformOffsetEXT(&program: UInt32; location: Int32): IntPtr :=
z_GetUniformOffsetEXT_ovr_0(&program, location);
end;
[PCUNotRestore]
glBlendColorEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendColorEXT_ovr_0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glBlendColorEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColorEXT(red: single; green: single; blue: single; alpha: single) :=
z_BlendColorEXT_ovr_0(red, green, blue, alpha);
end;
[PCUNotRestore]
glBlendEquationSeparateEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendEquationSeparateEXT_ovr_0(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationSeparateEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateEXT(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT) :=
z_BlendEquationSeparateEXT_ovr_0(modeRGB, modeAlpha);
end;
[PCUNotRestore]
glBlendFuncSeparateEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendFuncSeparateEXT_ovr_0(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor);
external 'opengl32.dll' name 'glBlendFuncSeparateEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateEXT(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor) :=
z_BlendFuncSeparateEXT_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
end;
[PCUNotRestore]
glBlendMinmaxEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendEquationEXT_ovr_0(mode: BlendEquationModeEXT);
external 'opengl32.dll' name 'glBlendEquationEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationEXT(mode: BlendEquationModeEXT) :=
z_BlendEquationEXT_ovr_0(mode);
end;
[PCUNotRestore]
glColorSubtableEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ColorSubTableEXT_ovr_0(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glColorSubTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorSubTableEXT(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ColorSubTableEXT_ovr_0(target, start, count, format, &type, data);
private static procedure z_CopyColorSubTableEXT_ovr_0(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyColorSubTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorSubTableEXT(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyColorSubTableEXT_ovr_0(target, start, x, y, width);
end;
[PCUNotRestore]
glCompiledVertexArrayEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_LockArraysEXT_ovr_0(first: Int32; count: Int32);
external 'opengl32.dll' name 'glLockArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LockArraysEXT(first: Int32; count: Int32) :=
z_LockArraysEXT_ovr_0(first, count);
private static procedure z_UnlockArraysEXT_ovr_0;
external 'opengl32.dll' name 'glUnlockArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnlockArraysEXT :=
z_UnlockArraysEXT_ovr_0;
end;
[PCUNotRestore]
glConvolutionEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ConvolutionFilter1DEXT_ovr_0(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glConvolutionFilter1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter1DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_ConvolutionFilter1DEXT_ovr_0(target, _internalformat, width, format, &type, image);
private static procedure z_ConvolutionFilter2DEXT_ovr_0(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glConvolutionFilter2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter2DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_ConvolutionFilter2DEXT_ovr_0(target, _internalformat, width, height, format, &type, image);
private static procedure z_ConvolutionParameterfEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: single);
external 'opengl32.dll' name 'glConvolutionParameterfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: single) :=
z_ConvolutionParameterfEXT_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterfvEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single);
external 'opengl32.dll' name 'glConvolutionParameterfvEXT';
private static procedure z_ConvolutionParameterfvEXT_ovr_0_anh0001(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_ConvolutionParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single) :=
z_ConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterfvEXT_ovr_2(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_ConvolutionParameterfvEXT_ovr_2(target, pname, ¶ms);
private static procedure z_ConvolutionParameteriEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: Int32);
external 'opengl32.dll' name 'glConvolutionParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteriEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: Int32) :=
z_ConvolutionParameteriEXT_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterivEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glConvolutionParameterivEXT';
private static procedure z_ConvolutionParameterivEXT_ovr_0_anh0001(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ConvolutionParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_ConvolutionParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32) :=
z_ConvolutionParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterivEXT_ovr_2(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_ConvolutionParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_CopyConvolutionFilter1DEXT_ovr_0(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyConvolutionFilter1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter1DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32) :=
z_CopyConvolutionFilter1DEXT_ovr_0(target, _internalformat, x, y, width);
private static procedure z_CopyConvolutionFilter2DEXT_ovr_0(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyConvolutionFilter2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter2DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyConvolutionFilter2DEXT_ovr_0(target, _internalformat, x, y, width, height);
private static procedure z_GetConvolutionFilterEXT_ovr_0(target: ConvolutionTargetEXT; format: PixelFormat; &type: PixelType; image: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionFilterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionFilterEXT(target: ConvolutionTargetEXT; format: PixelFormat; &type: PixelType; image: IntPtr) :=
z_GetConvolutionFilterEXT_ovr_0(target, format, &type, image);
private static procedure z_GetConvolutionParameterfvEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetConvolutionParameterfvEXT';
private static procedure z_GetConvolutionParameterfvEXT_ovr_0_anh0001(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetConvolutionParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single) :=
z_GetConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetConvolutionParameterfvEXT_ovr_2(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_GetConvolutionParameterfvEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetConvolutionParameterivEXT_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetConvolutionParameterivEXT';
private static procedure z_GetConvolutionParameterivEXT_ovr_0_anh0001(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetConvolutionParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetConvolutionParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32) :=
z_GetConvolutionParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetConvolutionParameterivEXT_ovr_2(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_GetConvolutionParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetSeparableFilterEXT_ovr_0(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr);
external 'opengl32.dll' name 'glGetSeparableFilterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSeparableFilterEXT(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr) :=
z_GetSeparableFilterEXT_ovr_0(target, format, &type, row, column, span);
private static procedure z_SeparableFilter2DEXT_ovr_0(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr);
external 'opengl32.dll' name 'glSeparableFilter2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SeparableFilter2DEXT(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr) :=
z_SeparableFilter2DEXT_ovr_0(target, _internalformat, width, height, format, &type, row, column);
end;
[PCUNotRestore]
glCoordinateFrameEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Tangent3bEXT_ovr_0(tx: SByte; ty: SByte; tz: SByte);
external 'opengl32.dll' name 'glTangent3bEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bEXT(tx: SByte; ty: SByte; tz: SByte) :=
z_Tangent3bEXT_ovr_0(tx, ty, tz);
private static procedure z_Tangent3bvEXT_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glTangent3bvEXT';
private static procedure z_Tangent3bvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTangent3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_Tangent3bvEXT_ovr_0(v[0]) else
z_Tangent3bvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(var v: SByte) :=
z_Tangent3bvEXT_ovr_0(v);
private static procedure z_Tangent3bvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTangent3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(v: IntPtr) :=
z_Tangent3bvEXT_ovr_2(v);
private static procedure z_Tangent3dEXT_ovr_0(tx: real; ty: real; tz: real);
external 'opengl32.dll' name 'glTangent3dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dEXT(tx: real; ty: real; tz: real) :=
z_Tangent3dEXT_ovr_0(tx, ty, tz);
private static procedure z_Tangent3dvEXT_ovr_0(var v: real);
external 'opengl32.dll' name 'glTangent3dvEXT';
private static procedure z_Tangent3dvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTangent3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Tangent3dvEXT_ovr_0(v[0]) else
z_Tangent3dvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(var v: real) :=
z_Tangent3dvEXT_ovr_0(v);
private static procedure z_Tangent3dvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTangent3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(v: IntPtr) :=
z_Tangent3dvEXT_ovr_2(v);
private static procedure z_Tangent3fEXT_ovr_0(tx: single; ty: single; tz: single);
external 'opengl32.dll' name 'glTangent3fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fEXT(tx: single; ty: single; tz: single) :=
z_Tangent3fEXT_ovr_0(tx, ty, tz);
private static procedure z_Tangent3fvEXT_ovr_0(var v: single);
external 'opengl32.dll' name 'glTangent3fvEXT';
private static procedure z_Tangent3fvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTangent3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Tangent3fvEXT_ovr_0(v[0]) else
z_Tangent3fvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(var v: single) :=
z_Tangent3fvEXT_ovr_0(v);
private static procedure z_Tangent3fvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTangent3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(v: IntPtr) :=
z_Tangent3fvEXT_ovr_2(v);
private static procedure z_Tangent3iEXT_ovr_0(tx: Int32; ty: Int32; tz: Int32);
external 'opengl32.dll' name 'glTangent3iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3iEXT(tx: Int32; ty: Int32; tz: Int32) :=
z_Tangent3iEXT_ovr_0(tx, ty, tz);
private static procedure z_Tangent3ivEXT_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glTangent3ivEXT';
private static procedure z_Tangent3ivEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTangent3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Tangent3ivEXT_ovr_0(v[0]) else
z_Tangent3ivEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(var v: Int32) :=
z_Tangent3ivEXT_ovr_0(v);
private static procedure z_Tangent3ivEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTangent3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(v: IntPtr) :=
z_Tangent3ivEXT_ovr_2(v);
private static procedure z_Tangent3sEXT_ovr_0(tx: Int16; ty: Int16; tz: Int16);
external 'opengl32.dll' name 'glTangent3sEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3sEXT(tx: Int16; ty: Int16; tz: Int16) :=
z_Tangent3sEXT_ovr_0(tx, ty, tz);
private static procedure z_Tangent3svEXT_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glTangent3svEXT';
private static procedure z_Tangent3svEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTangent3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Tangent3svEXT_ovr_0(v[0]) else
z_Tangent3svEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(var v: Int16) :=
z_Tangent3svEXT_ovr_0(v);
private static procedure z_Tangent3svEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTangent3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(v: IntPtr) :=
z_Tangent3svEXT_ovr_2(v);
private static procedure z_Binormal3bEXT_ovr_0(bx: SByte; by: SByte; bz: SByte);
external 'opengl32.dll' name 'glBinormal3bEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bEXT(bx: SByte; by: SByte; bz: SByte) :=
z_Binormal3bEXT_ovr_0(bx, by, bz);
private static procedure z_Binormal3bvEXT_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glBinormal3bvEXT';
private static procedure z_Binormal3bvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_Binormal3bvEXT_ovr_0(v[0]) else
z_Binormal3bvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(var v: SByte) :=
z_Binormal3bvEXT_ovr_0(v);
private static procedure z_Binormal3bvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(v: IntPtr) :=
z_Binormal3bvEXT_ovr_2(v);
private static procedure z_Binormal3dEXT_ovr_0(bx: real; by: real; bz: real);
external 'opengl32.dll' name 'glBinormal3dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dEXT(bx: real; by: real; bz: real) :=
z_Binormal3dEXT_ovr_0(bx, by, bz);
private static procedure z_Binormal3dvEXT_ovr_0(var v: real);
external 'opengl32.dll' name 'glBinormal3dvEXT';
private static procedure z_Binormal3dvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_Binormal3dvEXT_ovr_0(v[0]) else
z_Binormal3dvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(var v: real) :=
z_Binormal3dvEXT_ovr_0(v);
private static procedure z_Binormal3dvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(v: IntPtr) :=
z_Binormal3dvEXT_ovr_2(v);
private static procedure z_Binormal3fEXT_ovr_0(bx: single; by: single; bz: single);
external 'opengl32.dll' name 'glBinormal3fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fEXT(bx: single; by: single; bz: single) :=
z_Binormal3fEXT_ovr_0(bx, by, bz);
private static procedure z_Binormal3fvEXT_ovr_0(var v: single);
external 'opengl32.dll' name 'glBinormal3fvEXT';
private static procedure z_Binormal3fvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_Binormal3fvEXT_ovr_0(v[0]) else
z_Binormal3fvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(var v: single) :=
z_Binormal3fvEXT_ovr_0(v);
private static procedure z_Binormal3fvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(v: IntPtr) :=
z_Binormal3fvEXT_ovr_2(v);
private static procedure z_Binormal3iEXT_ovr_0(bx: Int32; by: Int32; bz: Int32);
external 'opengl32.dll' name 'glBinormal3iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3iEXT(bx: Int32; by: Int32; bz: Int32) :=
z_Binormal3iEXT_ovr_0(bx, by, bz);
private static procedure z_Binormal3ivEXT_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glBinormal3ivEXT';
private static procedure z_Binormal3ivEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_Binormal3ivEXT_ovr_0(v[0]) else
z_Binormal3ivEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(var v: Int32) :=
z_Binormal3ivEXT_ovr_0(v);
private static procedure z_Binormal3ivEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(v: IntPtr) :=
z_Binormal3ivEXT_ovr_2(v);
private static procedure z_Binormal3sEXT_ovr_0(bx: Int16; by: Int16; bz: Int16);
external 'opengl32.dll' name 'glBinormal3sEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3sEXT(bx: Int16; by: Int16; bz: Int16) :=
z_Binormal3sEXT_ovr_0(bx, by, bz);
private static procedure z_Binormal3svEXT_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glBinormal3svEXT';
private static procedure z_Binormal3svEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_Binormal3svEXT_ovr_0(v[0]) else
z_Binormal3svEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(var v: Int16) :=
z_Binormal3svEXT_ovr_0(v);
private static procedure z_Binormal3svEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glBinormal3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(v: IntPtr) :=
z_Binormal3svEXT_ovr_2(v);
private static procedure z_TangentPointerEXT_ovr_0(&type: TangentPointerTypeEXT; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glTangentPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TangentPointerEXT(&type: TangentPointerTypeEXT; stride: Int32; pointer: IntPtr) :=
z_TangentPointerEXT_ovr_0(&type, stride, pointer);
private static procedure z_BinormalPointerEXT_ovr_0(&type: BinormalPointerTypeEXT; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glBinormalPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BinormalPointerEXT(&type: BinormalPointerTypeEXT; stride: Int32; pointer: IntPtr) :=
z_BinormalPointerEXT_ovr_0(&type, stride, pointer);
end;
[PCUNotRestore]
glCopyTextureEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CopyTexImage1DEXT_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage1DEXT(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32) :=
z_CopyTexImage1DEXT_ovr_0(target, level, _internalformat, x, y, width, border);
private static procedure z_CopyTexImage2DEXT_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage2DEXT(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32) :=
z_CopyTexImage2DEXT_ovr_0(target, level, _internalformat, x, y, width, height, border);
private static procedure z_CopyTexSubImage1DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage1DEXT(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyTexSubImage1DEXT_ovr_0(target, level, xoffset, x, y, width);
private static procedure z_CopyTexSubImage2DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage2DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTexSubImage2DEXT_ovr_0(target, level, xoffset, yoffset, x, y, width, height);
private static procedure z_CopyTexSubImage3DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage3DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTexSubImage3DEXT_ovr_0(target, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
[PCUNotRestore]
glCullVertexEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CullParameterdvEXT_ovr_0(pname: CullParameterEXT; var ¶ms: real);
external 'opengl32.dll' name 'glCullParameterdvEXT';
private static procedure z_CullParameterdvEXT_ovr_0_anh001(pname: CullParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCullParameterdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_CullParameterdvEXT_ovr_0(pname, ¶ms[0]) else
z_CullParameterdvEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; var ¶ms: real) :=
z_CullParameterdvEXT_ovr_0(pname, ¶ms);
private static procedure z_CullParameterdvEXT_ovr_2(pname: CullParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCullParameterdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; ¶ms: IntPtr) :=
z_CullParameterdvEXT_ovr_2(pname, ¶ms);
private static procedure z_CullParameterfvEXT_ovr_0(pname: CullParameterEXT; var ¶ms: single);
external 'opengl32.dll' name 'glCullParameterfvEXT';
private static procedure z_CullParameterfvEXT_ovr_0_anh001(pname: CullParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCullParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_CullParameterfvEXT_ovr_0(pname, ¶ms[0]) else
z_CullParameterfvEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; var ¶ms: single) :=
z_CullParameterfvEXT_ovr_0(pname, ¶ms);
private static procedure z_CullParameterfvEXT_ovr_2(pname: CullParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCullParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; ¶ms: IntPtr) :=
z_CullParameterfvEXT_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glDebugLabelEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_LabelObjectEXT_ovr_0(&type: DummyEnum; object: UInt32; length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glLabelObjectEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LabelObjectEXT(&type: DummyEnum; object: UInt32; length: Int32; &label: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(&label);
z_LabelObjectEXT_ovr_0(&type, object, length, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LabelObjectEXT(&type: DummyEnum; object: UInt32; length: Int32; &label: IntPtr) :=
z_LabelObjectEXT_ovr_0(&type, object, length, &label);
private static procedure z_GetObjectLabelEXT_ovr_0(&type: DummyEnum; object: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabelEXT';
private static procedure z_GetObjectLabelEXT_ovr_0_anh000010(&type: DummyEnum; object: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabelEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; length: array of Int32; &label: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetObjectLabelEXT_ovr_0(&type, object, bufSize, length[0], &label) else
z_GetObjectLabelEXT_ovr_0_anh000010(&type, object, bufSize, IntPtr.Zero, &label);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr) :=
z_GetObjectLabelEXT_ovr_0(&type, object, bufSize, length, &label);
private static procedure z_GetObjectLabelEXT_ovr_2(&type: DummyEnum; object: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabelEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr) :=
z_GetObjectLabelEXT_ovr_2(&type, object, bufSize, length, &label);
end;
[PCUNotRestore]
glDebugMarkerEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_InsertEventMarkerEXT_ovr_0(length: Int32; marker: IntPtr);
external 'opengl32.dll' name 'glInsertEventMarkerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InsertEventMarkerEXT(length: Int32; marker: string);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(marker);
z_InsertEventMarkerEXT_ovr_0(length, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InsertEventMarkerEXT(length: Int32; marker: IntPtr) :=
z_InsertEventMarkerEXT_ovr_0(length, marker);
private static procedure z_PushGroupMarkerEXT_ovr_0(length: Int32; marker: IntPtr);
external 'opengl32.dll' name 'glPushGroupMarkerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushGroupMarkerEXT(length: Int32; marker: string);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(marker);
z_PushGroupMarkerEXT_ovr_0(length, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushGroupMarkerEXT(length: Int32; marker: IntPtr) :=
z_PushGroupMarkerEXT_ovr_0(length, marker);
private static procedure z_PopGroupMarkerEXT_ovr_0;
external 'opengl32.dll' name 'glPopGroupMarkerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopGroupMarkerEXT :=
z_PopGroupMarkerEXT_ovr_0;
end;
[PCUNotRestore]
glDepthBoundsTestEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DepthBoundsEXT_ovr_0(zmin: real; zmax: real);
external 'opengl32.dll' name 'glDepthBoundsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthBoundsEXT(zmin: real; zmax: real) :=
z_DepthBoundsEXT_ovr_0(zmin, zmax);
end;
[PCUNotRestore]
glDirectStateAccessEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MatrixLoadfEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
private static procedure z_MatrixLoadfEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadfEXT_ovr_0(mode, m[0]) else
z_MatrixLoadfEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; var m: single) :=
z_MatrixLoadfEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadfEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadfEXT_ovr_2(mode, m);
private static procedure z_MatrixLoaddEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
private static procedure z_MatrixLoaddEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoaddEXT_ovr_0(mode, m[0]) else
z_MatrixLoaddEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; var m: real) :=
z_MatrixLoaddEXT_ovr_0(mode, m);
private static procedure z_MatrixLoaddEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoaddEXT_ovr_2(mode, m);
private static procedure z_MatrixMultfEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixMultfEXT';
private static procedure z_MatrixMultfEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultfEXT_ovr_0(mode, m[0]) else
z_MatrixMultfEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; var m: single) :=
z_MatrixMultfEXT_ovr_0(mode, m);
private static procedure z_MatrixMultfEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultfEXT_ovr_2(mode, m);
private static procedure z_MatrixMultdEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixMultdEXT';
private static procedure z_MatrixMultdEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultdEXT_ovr_0(mode, m[0]) else
z_MatrixMultdEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; var m: real) :=
z_MatrixMultdEXT_ovr_0(mode, m);
private static procedure z_MatrixMultdEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultdEXT_ovr_2(mode, m);
private static procedure z_MatrixLoadIdentityEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixLoadIdentityEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadIdentityEXT(mode: MatrixMode) :=
z_MatrixLoadIdentityEXT_ovr_0(mode);
private static procedure z_MatrixRotatefEXT_ovr_0(mode: MatrixMode; angle: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixRotatefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatefEXT(mode: MatrixMode; angle: single; x: single; y: single; z: single) :=
z_MatrixRotatefEXT_ovr_0(mode, angle, x, y, z);
private static procedure z_MatrixRotatedEXT_ovr_0(mode: MatrixMode; angle: real; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixRotatedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatedEXT(mode: MatrixMode; angle: real; x: real; y: real; z: real) :=
z_MatrixRotatedEXT_ovr_0(mode, angle, x, y, z);
private static procedure z_MatrixScalefEXT_ovr_0(mode: MatrixMode; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixScalefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScalefEXT(mode: MatrixMode; x: single; y: single; z: single) :=
z_MatrixScalefEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixScaledEXT_ovr_0(mode: MatrixMode; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixScaledEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScaledEXT(mode: MatrixMode; x: real; y: real; z: real) :=
z_MatrixScaledEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixTranslatefEXT_ovr_0(mode: MatrixMode; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixTranslatefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatefEXT(mode: MatrixMode; x: single; y: single; z: single) :=
z_MatrixTranslatefEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixTranslatedEXT_ovr_0(mode: MatrixMode; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixTranslatedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatedEXT(mode: MatrixMode; x: real; y: real; z: real) :=
z_MatrixTranslatedEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixFrustumEXT_ovr_0(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glMatrixFrustumEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixFrustumEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_MatrixFrustumEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
private static procedure z_MatrixOrthoEXT_ovr_0(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glMatrixOrthoEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixOrthoEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_MatrixOrthoEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
private static procedure z_MatrixPopEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixPopEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPopEXT(mode: MatrixMode) :=
z_MatrixPopEXT_ovr_0(mode);
private static procedure z_MatrixPushEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixPushEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPushEXT(mode: MatrixMode) :=
z_MatrixPushEXT_ovr_0(mode);
private static procedure z_ClientAttribDefaultEXT_ovr_0(mask: ClientAttribMask);
external 'opengl32.dll' name 'glClientAttribDefaultEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientAttribDefaultEXT(mask: ClientAttribMask) :=
z_ClientAttribDefaultEXT_ovr_0(mask);
private static procedure z_PushClientAttribDefaultEXT_ovr_0(mask: ClientAttribMask);
external 'opengl32.dll' name 'glPushClientAttribDefaultEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushClientAttribDefaultEXT(mask: ClientAttribMask) :=
z_PushClientAttribDefaultEXT_ovr_0(mask);
private static procedure z_TextureParameterfEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: single);
external 'opengl32.dll' name 'glTextureParameterfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: single) :=
z_TextureParameterfEXT_ovr_0(texture, target, pname, param);
private static procedure z_TextureParameterfvEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glTextureParameterfvEXT';
private static procedure z_TextureParameterfvEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_TextureParameterfvEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: single) :=
z_TextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_TextureParameterfvEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterfvEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_TextureParameteriEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: Int32);
external 'opengl32.dll' name 'glTextureParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: Int32) :=
z_TextureParameteriEXT_ovr_0(texture, target, pname, param);
private static procedure z_TextureParameterivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTextureParameterivEXT';
private static procedure z_TextureParameterivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_TextureParameterivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_TextureParameterivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_TextureParameterivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_TextureImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureImage1DEXT_ovr_0(texture, target, level, internalformat, width, border, format, &type, pixels);
private static procedure z_TextureImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureImage2DEXT_ovr_0(texture, target, level, internalformat, width, height, border, format, &type, pixels);
private static procedure z_TextureSubImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, width, format, &type, pixels);
private static procedure z_TextureSubImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, width, height, format, &type, pixels);
private static procedure z_CopyTextureImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTextureImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32) :=
z_CopyTextureImage1DEXT_ovr_0(texture, target, level, _internalformat, x, y, width, border);
private static procedure z_CopyTextureImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTextureImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32) :=
z_CopyTextureImage2DEXT_ovr_0(texture, target, level, _internalformat, x, y, width, height, border);
private static procedure z_CopyTextureSubImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyTextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, x, y, width);
private static procedure z_CopyTextureSubImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, x, y, width, height);
private static procedure z_GetTextureImageEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glGetTextureImageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureImageEXT(texture: UInt32; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_GetTextureImageEXT_ovr_0(texture, target, level, format, &type, pixels);
private static procedure z_GetTextureParameterfvEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTextureParameterfvEXT';
private static procedure z_GetTextureParameterfvEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_GetTextureParameterfvEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterfvEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterfvEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureParameterivEXT';
private static procedure z_GetTextureParameterivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_GetTextureParameterivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameterivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_GetTextureLevelParameterfvEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTextureLevelParameterfvEXT';
private static procedure z_GetTextureLevelParameterfvEXT_ovr_0_anh000001(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameterfvEXT_ovr_0(texture, target, level, pname, ¶ms[0]) else
z_GetTextureLevelParameterfvEXT_ovr_0_anh000001(texture, target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetTextureLevelParameterfvEXT_ovr_0(texture, target, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameterfvEXT_ovr_2(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameterfvEXT_ovr_2(texture, target, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameterivEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureLevelParameterivEXT';
private static procedure z_GetTextureLevelParameterivEXT_ovr_0_anh000001(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureLevelParameterivEXT_ovr_0(texture, target, level, pname, ¶ms[0]) else
z_GetTextureLevelParameterivEXT_ovr_0_anh000001(texture, target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureLevelParameterivEXT_ovr_0(texture, target, level, pname, ¶ms);
private static procedure z_GetTextureLevelParameterivEXT_ovr_2(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureLevelParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureLevelParameterivEXT_ovr_2(texture, target, level, pname, ¶ms);
private static procedure z_TextureImage3DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage3DEXT(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureImage3DEXT_ovr_0(texture, target, level, internalformat, width, height, depth, border, format, &type, pixels);
private static procedure z_TextureSubImage3DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTextureSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage3DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
private static procedure z_CopyTextureSubImage3DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTextureSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage3DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyTextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
private static procedure z_BindMultiTextureEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; texture: UInt32);
external 'opengl32.dll' name 'glBindMultiTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindMultiTextureEXT(texunit: TextureUnit; target: TextureTarget; texture: UInt32) :=
z_BindMultiTextureEXT_ovr_0(texunit, target, texture);
private static procedure z_MultiTexCoordPointerEXT_ovr_0(texunit: TextureUnit; size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoordPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordPointerEXT(texunit: TextureUnit; size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr) :=
z_MultiTexCoordPointerEXT_ovr_0(texunit, size, &type, stride, pointer);
private static procedure z_MultiTexEnvfEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: single);
external 'opengl32.dll' name 'glMultiTexEnvfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: single) :=
z_MultiTexEnvfEXT_ovr_0(texunit, target, pname, param);
private static procedure z_MultiTexEnvfvEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glMultiTexEnvfvEXT';
private static procedure z_MultiTexEnvfvEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexEnvfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexEnvfvEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) :=
z_MultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexEnvfvEXT_ovr_2(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexEnvfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_MultiTexEnvfvEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_MultiTexEnviEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32);
external 'opengl32.dll' name 'glMultiTexEnviEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnviEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32) :=
z_MultiTexEnviEXT_ovr_0(texunit, target, pname, param);
private static procedure z_MultiTexEnvivEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glMultiTexEnvivEXT';
private static procedure z_MultiTexEnvivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexEnvivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexEnvivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) :=
z_MultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexEnvivEXT_ovr_2(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexEnvivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_MultiTexEnvivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_MultiTexGendEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: real);
external 'opengl32.dll' name 'glMultiTexGendEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: real) :=
z_MultiTexGendEXT_ovr_0(texunit, coord, pname, param);
private static procedure z_MultiTexGendvEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glMultiTexGendvEXT';
private static procedure z_MultiTexGendvEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGendvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_MultiTexGendvEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) :=
z_MultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexGendvEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGendvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_MultiTexGendvEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexGenfEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: single);
external 'opengl32.dll' name 'glMultiTexGenfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: single) :=
z_MultiTexGenfEXT_ovr_0(texunit, coord, pname, param);
private static procedure z_MultiTexGenfvEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glMultiTexGenfvEXT';
private static procedure z_MultiTexGenfvEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGenfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_MultiTexGenfvEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) :=
z_MultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexGenfvEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGenfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_MultiTexGenfvEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexGeniEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: Int32);
external 'opengl32.dll' name 'glMultiTexGeniEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGeniEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: Int32) :=
z_MultiTexGeniEXT_ovr_0(texunit, coord, pname, param);
private static procedure z_MultiTexGenivEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glMultiTexGenivEXT';
private static procedure z_MultiTexGenivEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGenivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_MultiTexGenivEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) :=
z_MultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexGenivEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexGenivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_MultiTexGenivEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexEnvfvEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMultiTexEnvfvEXT';
private static procedure z_GetMultiTexEnvfvEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexEnvfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexEnvfvEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) :=
z_GetMultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexEnvfvEXT_ovr_2(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexEnvfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_GetMultiTexEnvfvEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexEnvivEXT_ovr_0(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMultiTexEnvivEXT';
private static procedure z_GetMultiTexEnvivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexEnvivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexEnvivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) :=
z_GetMultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexEnvivEXT_ovr_2(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexEnvivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_GetMultiTexEnvivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexGendvEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glGetMultiTexGendvEXT';
private static procedure z_GetMultiTexGendvEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGendvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_GetMultiTexGendvEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) :=
z_GetMultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexGendvEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGendvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetMultiTexGendvEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexGenfvEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMultiTexGenfvEXT';
private static procedure z_GetMultiTexGenfvEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGenfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_GetMultiTexGenfvEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) :=
z_GetMultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexGenfvEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGenfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetMultiTexGenfvEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexGenivEXT_ovr_0(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMultiTexGenivEXT';
private static procedure z_GetMultiTexGenivEXT_ovr_0_anh00001(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGenivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms[0]) else
z_GetMultiTexGenivEXT_ovr_0_anh00001(texunit, coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) :=
z_GetMultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms);
private static procedure z_GetMultiTexGenivEXT_ovr_2(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexGenivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetMultiTexGenivEXT_ovr_2(texunit, coord, pname, ¶ms);
private static procedure z_MultiTexParameteriEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: Int32);
external 'opengl32.dll' name 'glMultiTexParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameteriEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: Int32) :=
z_MultiTexParameteriEXT_ovr_0(texunit, target, pname, param);
private static procedure z_MultiTexParameterivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glMultiTexParameterivEXT';
private static procedure z_MultiTexParameterivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexParameterivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_MultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_MultiTexParameterivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterfEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: single);
external 'opengl32.dll' name 'glMultiTexParameterfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: single) :=
z_MultiTexParameterfEXT_ovr_0(texunit, target, pname, param);
private static procedure z_MultiTexParameterfvEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glMultiTexParameterfvEXT';
private static procedure z_MultiTexParameterfvEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexParameterfvEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: single) :=
z_MultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterfvEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_MultiTexParameterfvEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_MultiTexImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexImage1DEXT_ovr_0(texunit, target, level, internalformat, width, border, format, &type, pixels);
private static procedure z_MultiTexImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexImage2DEXT_ovr_0(texunit, target, level, internalformat, width, height, border, format, &type, pixels);
private static procedure z_MultiTexSubImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, width, format, &type, pixels);
private static procedure z_MultiTexSubImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexSubImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, width, height, format, &type, pixels);
private static procedure z_CopyMultiTexImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyMultiTexImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32) :=
z_CopyMultiTexImage1DEXT_ovr_0(texunit, target, level, _internalformat, x, y, width, border);
private static procedure z_CopyMultiTexImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyMultiTexImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32) :=
z_CopyMultiTexImage2DEXT_ovr_0(texunit, target, level, _internalformat, x, y, width, height, border);
private static procedure z_CopyMultiTexSubImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyMultiTexSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) :=
z_CopyMultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, x, y, width);
private static procedure z_CopyMultiTexSubImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyMultiTexSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexSubImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyMultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, x, y, width, height);
private static procedure z_GetMultiTexImageEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexImageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexImageEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_GetMultiTexImageEXT_ovr_0(texunit, target, level, format, &type, pixels);
private static procedure z_GetMultiTexParameterfvEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMultiTexParameterfvEXT';
private static procedure z_GetMultiTexParameterfvEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexParameterfvEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single) :=
z_GetMultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterfvEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexParameterfvEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMultiTexParameterivEXT';
private static procedure z_GetMultiTexParameterivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexParameterivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetMultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexParameterivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexLevelParameterfvEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterfvEXT';
private static procedure z_GetMultiTexLevelParameterfvEXT_ovr_0_anh000001(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexLevelParameterfvEXT_ovr_0(texunit, target, level, pname, ¶ms[0]) else
z_GetMultiTexLevelParameterfvEXT_ovr_0_anh000001(texunit, target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single) :=
z_GetMultiTexLevelParameterfvEXT_ovr_0(texunit, target, level, pname, ¶ms);
private static procedure z_GetMultiTexLevelParameterfvEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexLevelParameterfvEXT_ovr_2(texunit, target, level, pname, ¶ms);
private static procedure z_GetMultiTexLevelParameterivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterivEXT';
private static procedure z_GetMultiTexLevelParameterivEXT_ovr_0_anh000001(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexLevelParameterivEXT_ovr_0(texunit, target, level, pname, ¶ms[0]) else
z_GetMultiTexLevelParameterivEXT_ovr_0_anh000001(texunit, target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetMultiTexLevelParameterivEXT_ovr_0(texunit, target, level, pname, ¶ms);
private static procedure z_GetMultiTexLevelParameterivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexLevelParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexLevelParameterivEXT_ovr_2(texunit, target, level, pname, ¶ms);
private static procedure z_MultiTexImage3DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexImage3DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexImage3DEXT_ovr_0(texunit, target, level, internalformat, width, height, depth, border, format, &type, pixels);
private static procedure z_MultiTexSubImage3DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glMultiTexSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexSubImage3DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_MultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
private static procedure z_CopyMultiTexSubImage3DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyMultiTexSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexSubImage3DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) :=
z_CopyMultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
private static procedure z_EnableClientStateIndexedEXT_ovr_0(&array: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glEnableClientStateIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientStateIndexedEXT(&array: EnableCap; index: UInt32) :=
z_EnableClientStateIndexedEXT_ovr_0(&array, index);
private static procedure z_DisableClientStateIndexedEXT_ovr_0(&array: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glDisableClientStateIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientStateIndexedEXT(&array: EnableCap; index: UInt32) :=
z_DisableClientStateIndexedEXT_ovr_0(&array, index);
private static procedure z_GetFloatIndexedvEXT_ovr_0(target: DummyEnum; index: UInt32; var data: single);
external 'opengl32.dll' name 'glGetFloatIndexedvEXT';
private static procedure z_GetFloatIndexedvEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetFloatIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetFloatIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetFloatIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; var data: single) :=
z_GetFloatIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetFloatIndexedvEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetFloatIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetFloatIndexedvEXT_ovr_2(target, index, data);
private static procedure z_GetDoubleIndexedvEXT_ovr_0(target: DummyEnum; index: UInt32; var data: real);
external 'opengl32.dll' name 'glGetDoubleIndexedvEXT';
private static procedure z_GetDoubleIndexedvEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetDoubleIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; data: array of real) :=
if (data<>nil) and (data.Length<>0) then
z_GetDoubleIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetDoubleIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; var data: real) :=
z_GetDoubleIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetDoubleIndexedvEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetDoubleIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetDoubleIndexedvEXT_ovr_2(target, index, data);
private static procedure z_GetPointerIndexedvEXT_ovr_0(target: DummyEnum; index: UInt32; var data: IntPtr);
external 'opengl32.dll' name 'glGetPointerIndexedvEXT';
private static procedure z_GetPointerIndexedvEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetPointerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of IntPtr) :=
if (data<>nil) and (data.Length<>0) then
z_GetPointerIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetPointerIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; var data: IntPtr) :=
z_GetPointerIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetPointerIndexedvEXT_ovr_2(target: DummyEnum; index: UInt32; data: pointer);
external 'opengl32.dll' name 'glGetPointerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; data: pointer) :=
z_GetPointerIndexedvEXT_ovr_2(target, index, data);
private static procedure z_EnableIndexedEXT_ovr_0(target: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glEnableIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableIndexedEXT(target: EnableCap; index: UInt32) :=
z_EnableIndexedEXT_ovr_0(target, index);
private static procedure z_DisableIndexedEXT_ovr_0(target: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glDisableIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableIndexedEXT(target: EnableCap; index: UInt32) :=
z_DisableIndexedEXT_ovr_0(target, index);
private static function z_IsEnabledIndexedEXT_ovr_0(target: EnableCap; index: UInt32): boolean;
external 'opengl32.dll' name 'glIsEnabledIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabledIndexedEXT(target: EnableCap; index: UInt32): boolean :=
z_IsEnabledIndexedEXT_ovr_0(target, index);
private static procedure z_GetIntegerIndexedvEXT_ovr_0(target: DummyEnum; index: UInt32; var data: Int32);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
private static procedure z_GetIntegerIndexedvEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetIntegerIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetIntegerIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; var data: Int32) :=
z_GetIntegerIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetIntegerIndexedvEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetIntegerIndexedvEXT_ovr_2(target, index, data);
private static procedure z_GetBooleanIndexedvEXT_ovr_0(target: BufferTargetARB; index: UInt32; var data: boolean);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
private static procedure z_GetBooleanIndexedvEXT_ovr_0_anh0001(target: BufferTargetARB; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetBooleanIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean) :=
z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetBooleanIndexedvEXT_ovr_2(target: BufferTargetARB; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
private static procedure z_CompressedTextureImage3DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureImage3DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureImage3DEXT_ovr_0(texture, target, level, _internalformat, width, height, depth, border, imageSize, bits);
private static procedure z_CompressedTextureImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureImage2DEXT_ovr_0(texture, target, level, _internalformat, width, height, border, imageSize, bits);
private static procedure z_CompressedTextureImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureImage1DEXT_ovr_0(texture, target, level, _internalformat, width, border, imageSize, bits);
private static procedure z_CompressedTextureSubImage3DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage3DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
private static procedure z_CompressedTextureSubImage2DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
private static procedure z_CompressedTextureSubImage1DEXT_ovr_0(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedTextureSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedTextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, width, format, imageSize, bits);
private static procedure z_GetCompressedTextureImageEXT_ovr_0(texture: UInt32; target: TextureTarget; lod: Int32; img: IntPtr);
external 'opengl32.dll' name 'glGetCompressedTextureImageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureImageEXT(texture: UInt32; target: TextureTarget; lod: Int32; img: IntPtr) :=
z_GetCompressedTextureImageEXT_ovr_0(texture, target, lod, img);
private static procedure z_CompressedMultiTexImage3DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexImage3DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexImage3DEXT_ovr_0(texunit, target, level, _internalformat, width, height, depth, border, imageSize, bits);
private static procedure z_CompressedMultiTexImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexImage2DEXT_ovr_0(texunit, target, level, _internalformat, width, height, border, imageSize, bits);
private static procedure z_CompressedMultiTexImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexImage1DEXT_ovr_0(texunit, target, level, _internalformat, width, border, imageSize, bits);
private static procedure z_CompressedMultiTexSubImage3DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexSubImage3DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
private static procedure z_CompressedMultiTexSubImage2DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexSubImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
private static procedure z_CompressedMultiTexSubImage1DEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
external 'opengl32.dll' name 'glCompressedMultiTexSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr) :=
z_CompressedMultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, width, format, imageSize, bits);
private static procedure z_GetCompressedMultiTexImageEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; lod: Int32; img: IntPtr);
external 'opengl32.dll' name 'glGetCompressedMultiTexImageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedMultiTexImageEXT(texunit: TextureUnit; target: TextureTarget; lod: Int32; img: IntPtr) :=
z_GetCompressedMultiTexImageEXT_ovr_0(texunit, target, lod, img);
private static procedure z_MatrixLoadTransposefEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
private static procedure z_MatrixLoadTransposefEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadTransposefEXT_ovr_0(mode, m[0]) else
z_MatrixLoadTransposefEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; var m: single) :=
z_MatrixLoadTransposefEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadTransposefEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadTransposefEXT_ovr_2(mode, m);
private static procedure z_MatrixLoadTransposedEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
private static procedure z_MatrixLoadTransposedEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadTransposedEXT_ovr_0(mode, m[0]) else
z_MatrixLoadTransposedEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; var m: real) :=
z_MatrixLoadTransposedEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadTransposedEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadTransposedEXT_ovr_2(mode, m);
private static procedure z_MatrixMultTransposefEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
private static procedure z_MatrixMultTransposefEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultTransposefEXT_ovr_0(mode, m[0]) else
z_MatrixMultTransposefEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; var m: single) :=
z_MatrixMultTransposefEXT_ovr_0(mode, m);
private static procedure z_MatrixMultTransposefEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultTransposefEXT_ovr_2(mode, m);
private static procedure z_MatrixMultTransposedEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
private static procedure z_MatrixMultTransposedEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultTransposedEXT_ovr_0(mode, m[0]) else
z_MatrixMultTransposedEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; var m: real) :=
z_MatrixMultTransposedEXT_ovr_0(mode, m);
private static procedure z_MatrixMultTransposedEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultTransposedEXT_ovr_2(mode, m);
private static procedure z_NamedBufferDataEXT_ovr_0(buffer: UInt32; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage);
external 'opengl32.dll' name 'glNamedBufferDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferDataEXT(buffer: UInt32; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage) :=
z_NamedBufferDataEXT_ovr_0(buffer, size, data, usage);
private static procedure z_NamedBufferSubDataEXT_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glNamedBufferSubDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubDataEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_NamedBufferSubDataEXT_ovr_0(buffer, offset, size, data);
private static function z_MapNamedBufferEXT_ovr_0(buffer: UInt32; access: BufferAccessARB): IntPtr;
external 'opengl32.dll' name 'glMapNamedBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferEXT(buffer: UInt32; access: BufferAccessARB): IntPtr :=
z_MapNamedBufferEXT_ovr_0(buffer, access);
private static function z_UnmapNamedBufferEXT_ovr_0(buffer: UInt32): boolean;
external 'opengl32.dll' name 'glUnmapNamedBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapNamedBufferEXT(buffer: UInt32): boolean :=
z_UnmapNamedBufferEXT_ovr_0(buffer);
private static procedure z_GetNamedBufferParameterivEXT_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedBufferParameterivEXT';
private static procedure z_GetNamedBufferParameterivEXT_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameterivEXT_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameterivEXT_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32) :=
z_GetNamedBufferParameterivEXT_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferParameterivEXT_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameterivEXT_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferPointervEXT_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferPointervEXT';
private static procedure z_GetNamedBufferPointervEXT_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferPointervEXT_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferPointervEXT_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr) :=
z_GetNamedBufferPointervEXT_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferPointervEXT_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer);
external 'opengl32.dll' name 'glGetNamedBufferPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer) :=
z_GetNamedBufferPointervEXT_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferSubDataEXT_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferSubDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubDataEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_GetNamedBufferSubDataEXT_ovr_0(buffer, offset, size, data);
private static procedure z_ProgramUniform1fEXT_ovr_0(&program: UInt32; location: Int32; v0: single);
external 'opengl32.dll' name 'glProgramUniform1fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fEXT(&program: UInt32; location: Int32; v0: single) :=
z_ProgramUniform1fEXT_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform2fEXT_ovr_0(&program: UInt32; location: Int32; v0: single; v1: single);
external 'opengl32.dll' name 'glProgramUniform2fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fEXT(&program: UInt32; location: Int32; v0: single; v1: single) :=
z_ProgramUniform2fEXT_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform3fEXT_ovr_0(&program: UInt32; location: Int32; v0: single; v1: single; v2: single);
external 'opengl32.dll' name 'glProgramUniform3fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fEXT(&program: UInt32; location: Int32; v0: single; v1: single; v2: single) :=
z_ProgramUniform3fEXT_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform4fEXT_ovr_0(&program: UInt32; location: Int32; v0: single; v1: single; v2: single; v3: single);
external 'opengl32.dll' name 'glProgramUniform4fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fEXT(&program: UInt32; location: Int32; v0: single; v1: single; v2: single; v3: single) :=
z_ProgramUniform4fEXT_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform1iEXT_ovr_0(&program: UInt32; location: Int32; v0: Int32);
external 'opengl32.dll' name 'glProgramUniform1iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iEXT(&program: UInt32; location: Int32; v0: Int32) :=
z_ProgramUniform1iEXT_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform2iEXT_ovr_0(&program: UInt32; location: Int32; v0: Int32; v1: Int32);
external 'opengl32.dll' name 'glProgramUniform2iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32) :=
z_ProgramUniform2iEXT_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform3iEXT_ovr_0(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32);
external 'opengl32.dll' name 'glProgramUniform3iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32) :=
z_ProgramUniform3iEXT_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform4iEXT_ovr_0(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32);
external 'opengl32.dll' name 'glProgramUniform4iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32) :=
z_ProgramUniform4iEXT_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform1fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform1fvEXT';
private static procedure z_ProgramUniform1fvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1fvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1fvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform1fvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1fvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform2fvEXT';
private static procedure z_ProgramUniform2fvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2fvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2fvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform2fvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2fvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform3fvEXT';
private static procedure z_ProgramUniform3fvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3fvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3fvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform3fvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3fvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: single);
external 'opengl32.dll' name 'glProgramUniform4fvEXT';
private static procedure z_ProgramUniform4fvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4fvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4fvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single) :=
z_ProgramUniform4fvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4fvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1ivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform1ivEXT';
private static procedure z_ProgramUniform1ivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1ivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1ivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform1ivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1ivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1ivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2ivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform2ivEXT';
private static procedure z_ProgramUniform2ivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2ivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2ivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform2ivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2ivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2ivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3ivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform3ivEXT';
private static procedure z_ProgramUniform3ivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3ivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3ivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform3ivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3ivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3ivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4ivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int32);
external 'opengl32.dll' name 'glProgramUniform4ivEXT';
private static procedure z_ProgramUniform4ivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4ivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4ivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32) :=
z_ProgramUniform4ivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4ivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4ivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniformMatrix2fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2fvEXT';
private static procedure z_ProgramUniformMatrix2fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3fvEXT';
private static procedure z_ProgramUniformMatrix3fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4fvEXT';
private static procedure z_ProgramUniformMatrix4fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fvEXT';
private static procedure z_ProgramUniformMatrix2x3fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x3fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fvEXT';
private static procedure z_ProgramUniformMatrix3x2fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x2fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fvEXT';
private static procedure z_ProgramUniformMatrix2x4fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix2x4fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fvEXT';
private static procedure z_ProgramUniformMatrix4x2fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x2fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fvEXT';
private static procedure z_ProgramUniformMatrix3x4fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix3x4fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3fvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fvEXT';
private static procedure z_ProgramUniformMatrix4x3fvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3fvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3fvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single) :=
z_ProgramUniformMatrix4x3fvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3fvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3fvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_TextureBufferEXT_ovr_0(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
external 'opengl32.dll' name 'glTextureBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferEXT(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32) :=
z_TextureBufferEXT_ovr_0(texture, target, _internalformat, buffer);
private static procedure z_MultiTexBufferEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; internalformat: DummyEnum; buffer: UInt32);
external 'opengl32.dll' name 'glMultiTexBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexBufferEXT(texunit: TextureUnit; target: TextureTarget; internalformat: DummyEnum; buffer: UInt32) :=
z_MultiTexBufferEXT_ovr_0(texunit, target, internalformat, buffer);
private static procedure z_TextureParameterIivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTextureParameterIivEXT';
private static procedure z_TextureParameterIivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_TextureParameterIivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_TextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_TextureParameterIivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_TextureParameterIuivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
external 'opengl32.dll' name 'glTextureParameterIuivEXT';
private static procedure z_TextureParameterIuivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_TextureParameterIuivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32) :=
z_TextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_TextureParameterIuivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTextureParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TextureParameterIuivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterIivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTextureParameterIivEXT';
private static procedure z_GetTextureParameterIivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_GetTextureParameterIivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterIivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterIuivEXT_ovr_0(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetTextureParameterIuivEXT';
private static procedure z_GetTextureParameterIuivEXT_ovr_0_anh00001(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms[0]) else
z_GetTextureParameterIuivEXT_ovr_0_anh00001(texture, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetTextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms);
private static procedure z_GetTextureParameterIuivEXT_ovr_2(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTextureParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTextureParameterIuivEXT_ovr_2(texture, target, pname, ¶ms);
private static procedure z_MultiTexParameterIivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glMultiTexParameterIivEXT';
private static procedure z_MultiTexParameterIivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexParameterIivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_MultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterIivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_MultiTexParameterIivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterIuivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
external 'opengl32.dll' name 'glMultiTexParameterIuivEXT';
private static procedure z_MultiTexParameterIuivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_MultiTexParameterIuivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32) :=
z_MultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_MultiTexParameterIuivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMultiTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_MultiTexParameterIuivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterIivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMultiTexParameterIivEXT';
private static procedure z_GetMultiTexParameterIivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexParameterIivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetMultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterIivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexParameterIivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterIuivEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetMultiTexParameterIuivEXT';
private static procedure z_GetMultiTexParameterIuivEXT_ovr_0_anh00001(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms[0]) else
z_GetMultiTexParameterIuivEXT_ovr_0_anh00001(texunit, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetMultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms);
private static procedure z_GetMultiTexParameterIuivEXT_ovr_2(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMultiTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetMultiTexParameterIuivEXT_ovr_2(texunit, target, pname, ¶ms);
private static procedure z_ProgramUniform1uiEXT_ovr_0(&program: UInt32; location: Int32; v0: UInt32);
external 'opengl32.dll' name 'glProgramUniform1uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiEXT(&program: UInt32; location: Int32; v0: UInt32) :=
z_ProgramUniform1uiEXT_ovr_0(&program, location, v0);
private static procedure z_ProgramUniform2uiEXT_ovr_0(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32);
external 'opengl32.dll' name 'glProgramUniform2uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32) :=
z_ProgramUniform2uiEXT_ovr_0(&program, location, v0, v1);
private static procedure z_ProgramUniform3uiEXT_ovr_0(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32);
external 'opengl32.dll' name 'glProgramUniform3uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32) :=
z_ProgramUniform3uiEXT_ovr_0(&program, location, v0, v1, v2);
private static procedure z_ProgramUniform4uiEXT_ovr_0(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32);
external 'opengl32.dll' name 'glProgramUniform4uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32) :=
z_ProgramUniform4uiEXT_ovr_0(&program, location, v0, v1, v2, v3);
private static procedure z_ProgramUniform1uivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform1uivEXT';
private static procedure z_ProgramUniform1uivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1uivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1uivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform1uivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1uivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1uivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2uivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform2uivEXT';
private static procedure z_ProgramUniform2uivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2uivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2uivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform2uivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2uivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2uivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3uivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform3uivEXT';
private static procedure z_ProgramUniform3uivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3uivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3uivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform3uivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3uivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3uivEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4uivEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glProgramUniform4uivEXT';
private static procedure z_ProgramUniform4uivEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4uivEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4uivEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32) :=
z_ProgramUniform4uivEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4uivEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4uivEXT_ovr_2(&program, location, count, value);
private static procedure z_NamedProgramLocalParameters4fvEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glNamedProgramLocalParameters4fvEXT';
private static procedure z_NamedProgramLocalParameters4fvEXT_ovr_0_anh000001(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParameters4fvEXT_ovr_0(&program, target, index, count, ¶ms[0]) else
z_NamedProgramLocalParameters4fvEXT_ovr_0_anh000001(&program, target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single) :=
z_NamedProgramLocalParameters4fvEXT_ovr_0(&program, target, index, count, ¶ms);
private static procedure z_NamedProgramLocalParameters4fvEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_NamedProgramLocalParameters4fvEXT_ovr_2(&program, target, index, count, ¶ms);
private static procedure z_NamedProgramLocalParameterI4iEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4iEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_NamedProgramLocalParameterI4iEXT_ovr_0(&program, target, index, x, y, z, w);
private static procedure z_NamedProgramLocalParameterI4ivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4ivEXT';
private static procedure z_NamedProgramLocalParameterI4ivEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParameterI4ivEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_NamedProgramLocalParameterI4ivEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_NamedProgramLocalParameterI4ivEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParameterI4ivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_NamedProgramLocalParameterI4ivEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParametersI4ivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4ivEXT';
private static procedure z_NamedProgramLocalParametersI4ivEXT_ovr_0_anh000001(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParametersI4ivEXT_ovr_0(&program, target, index, count, ¶ms[0]) else
z_NamedProgramLocalParametersI4ivEXT_ovr_0_anh000001(&program, target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32) :=
z_NamedProgramLocalParametersI4ivEXT_ovr_0(&program, target, index, count, ¶ms);
private static procedure z_NamedProgramLocalParametersI4ivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_NamedProgramLocalParametersI4ivEXT_ovr_2(&program, target, index, count, ¶ms);
private static procedure z_NamedProgramLocalParameterI4uiEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uiEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32) :=
z_NamedProgramLocalParameterI4uiEXT_ovr_0(&program, target, index, x, y, z, w);
private static procedure z_NamedProgramLocalParameterI4uivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4uivEXT';
private static procedure z_NamedProgramLocalParameterI4uivEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParameterI4uivEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_NamedProgramLocalParameterI4uivEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_NamedProgramLocalParameterI4uivEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParameterI4uivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameterI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_NamedProgramLocalParameterI4uivEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParametersI4uivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4uivEXT';
private static procedure z_NamedProgramLocalParametersI4uivEXT_ovr_0_anh000001(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParametersI4uivEXT_ovr_0(&program, target, index, count, ¶ms[0]) else
z_NamedProgramLocalParametersI4uivEXT_ovr_0_anh000001(&program, target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32) :=
z_NamedProgramLocalParametersI4uivEXT_ovr_0(&program, target, index, count, ¶ms);
private static procedure z_NamedProgramLocalParametersI4uivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParametersI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_NamedProgramLocalParametersI4uivEXT_ovr_2(&program, target, index, count, ¶ms);
private static procedure z_GetNamedProgramLocalParameterIivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIivEXT';
private static procedure z_GetNamedProgramLocalParameterIivEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedProgramLocalParameterIivEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_GetNamedProgramLocalParameterIivEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_GetNamedProgramLocalParameterIivEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterIivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetNamedProgramLocalParameterIivEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterIuivEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIuivEXT';
private static procedure z_GetNamedProgramLocalParameterIuivEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedProgramLocalParameterIuivEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_GetNamedProgramLocalParameterIuivEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_GetNamedProgramLocalParameterIuivEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterIuivEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetNamedProgramLocalParameterIuivEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_EnableClientStateiEXT_ovr_0(&array: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glEnableClientStateiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientStateiEXT(&array: EnableCap; index: UInt32) :=
z_EnableClientStateiEXT_ovr_0(&array, index);
private static procedure z_DisableClientStateiEXT_ovr_0(&array: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glDisableClientStateiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientStateiEXT(&array: EnableCap; index: UInt32) :=
z_DisableClientStateiEXT_ovr_0(&array, index);
private static procedure z_GetFloati_vEXT_ovr_0(pname: DummyEnum; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetFloati_vEXT';
private static procedure z_GetFloati_vEXT_ovr_0_anh0001(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFloati_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFloati_vEXT_ovr_0(pname, index, ¶ms[0]) else
z_GetFloati_vEXT_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: single) :=
z_GetFloati_vEXT_ovr_0(pname, index, ¶ms);
private static procedure z_GetFloati_vEXT_ovr_2(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFloati_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; ¶ms: IntPtr) :=
z_GetFloati_vEXT_ovr_2(pname, index, ¶ms);
private static procedure z_GetDoublei_vEXT_ovr_0(pname: DummyEnum; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetDoublei_vEXT';
private static procedure z_GetDoublei_vEXT_ovr_0_anh0001(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetDoublei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetDoublei_vEXT_ovr_0(pname, index, ¶ms[0]) else
z_GetDoublei_vEXT_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: real) :=
z_GetDoublei_vEXT_ovr_0(pname, index, ¶ms);
private static procedure z_GetDoublei_vEXT_ovr_2(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetDoublei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; ¶ms: IntPtr) :=
z_GetDoublei_vEXT_ovr_2(pname, index, ¶ms);
private static procedure z_GetPointeri_vEXT_ovr_0(pname: DummyEnum; index: UInt32; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointeri_vEXT';
private static procedure z_GetPointeri_vEXT_ovr_0_anh0001(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPointeri_vEXT_ovr_0(pname, index, ¶ms[0]) else
z_GetPointeri_vEXT_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: IntPtr) :=
z_GetPointeri_vEXT_ovr_0(pname, index, ¶ms);
private static procedure z_GetPointeri_vEXT_ovr_2(pname: DummyEnum; index: UInt32; ¶ms: pointer);
external 'opengl32.dll' name 'glGetPointeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; ¶ms: pointer) :=
z_GetPointeri_vEXT_ovr_2(pname, index, ¶ms);
private static procedure z_NamedProgramStringEXT_ovr_0(&program: UInt32; target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
external 'opengl32.dll' name 'glNamedProgramStringEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramStringEXT(&program: UInt32; target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr) :=
z_NamedProgramStringEXT_ovr_0(&program, target, format, len, string);
private static procedure z_NamedProgramLocalParameter4dEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real) :=
z_NamedProgramLocalParameter4dEXT_ovr_0(&program, target, index, x, y, z, w);
private static procedure z_NamedProgramLocalParameter4dvEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4dvEXT';
private static procedure z_NamedProgramLocalParameter4dvEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParameter4dvEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_NamedProgramLocalParameter4dvEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_NamedProgramLocalParameter4dvEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParameter4dvEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_NamedProgramLocalParameter4dvEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParameter4fEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single) :=
z_NamedProgramLocalParameter4fEXT_ovr_0(&program, target, index, x, y, z, w);
private static procedure z_NamedProgramLocalParameter4fvEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4fvEXT';
private static procedure z_NamedProgramLocalParameter4fvEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_NamedProgramLocalParameter4fvEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_NamedProgramLocalParameter4fvEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_NamedProgramLocalParameter4fvEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_NamedProgramLocalParameter4fvEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glNamedProgramLocalParameter4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_NamedProgramLocalParameter4fvEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterdvEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterdvEXT';
private static procedure z_GetNamedProgramLocalParameterdvEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedProgramLocalParameterdvEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_GetNamedProgramLocalParameterdvEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real) :=
z_GetNamedProgramLocalParameterdvEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterdvEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetNamedProgramLocalParameterdvEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterfvEXT_ovr_0(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterfvEXT';
private static procedure z_GetNamedProgramLocalParameterfvEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedProgramLocalParameterfvEXT_ovr_0(&program, target, index, ¶ms[0]) else
z_GetNamedProgramLocalParameterfvEXT_ovr_0_anh00001(&program, target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single) :=
z_GetNamedProgramLocalParameterfvEXT_ovr_0(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramLocalParameterfvEXT_ovr_2(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramLocalParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetNamedProgramLocalParameterfvEXT_ovr_2(&program, target, index, ¶ms);
private static procedure z_GetNamedProgramivEXT_ovr_0(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedProgramivEXT';
private static procedure z_GetNamedProgramivEXT_ovr_0_anh00001(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedProgramivEXT_ovr_0(&program, target, pname, ¶ms[0]) else
z_GetNamedProgramivEXT_ovr_0_anh00001(&program, target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32) :=
z_GetNamedProgramivEXT_ovr_0(&program, target, pname, ¶ms);
private static procedure z_GetNamedProgramivEXT_ovr_2(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr) :=
z_GetNamedProgramivEXT_ovr_2(&program, target, pname, ¶ms);
private static procedure z_GetNamedProgramStringEXT_ovr_0(&program: UInt32; target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
external 'opengl32.dll' name 'glGetNamedProgramStringEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramStringEXT(&program: UInt32; target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr) :=
z_GetNamedProgramStringEXT_ovr_0(&program, target, pname, string);
private static procedure z_NamedRenderbufferStorageEXT_ovr_0(renderbuffer: UInt32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageEXT(renderbuffer: UInt32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageEXT_ovr_0(renderbuffer, _internalformat, width, height);
private static procedure z_GetNamedRenderbufferParameterivEXT_ovr_0(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameterivEXT';
private static procedure z_GetNamedRenderbufferParameterivEXT_ovr_0_anh0001(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedRenderbufferParameterivEXT_ovr_0(renderbuffer, pname, ¶ms[0]) else
z_GetNamedRenderbufferParameterivEXT_ovr_0_anh0001(renderbuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetNamedRenderbufferParameterivEXT_ovr_0(renderbuffer, pname, ¶ms);
private static procedure z_GetNamedRenderbufferParameterivEXT_ovr_2(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedRenderbufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetNamedRenderbufferParameterivEXT_ovr_2(renderbuffer, pname, ¶ms);
private static procedure z_NamedRenderbufferStorageMultisampleEXT_ovr_0(renderbuffer: UInt32; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorageMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleEXT(renderbuffer: UInt32; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageMultisampleEXT_ovr_0(renderbuffer, samples, _internalformat, width, height);
private static procedure z_NamedRenderbufferStorageMultisampleCoverageEXT_ovr_0(renderbuffer: UInt32; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glNamedRenderbufferStorageMultisampleCoverageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: UInt32; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_NamedRenderbufferStorageMultisampleCoverageEXT_ovr_0(renderbuffer, coverageSamples, colorSamples, _internalformat, width, height);
private static function z_CheckNamedFramebufferStatusEXT_ovr_0(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus;
external 'opengl32.dll' name 'glCheckNamedFramebufferStatusEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckNamedFramebufferStatusEXT(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus :=
z_CheckNamedFramebufferStatusEXT_ovr_0(framebuffer, target);
private static procedure z_NamedFramebufferTexture1DEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTexture1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture1DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_NamedFramebufferTexture1DEXT_ovr_0(framebuffer, attachment, textarget, texture, level);
private static procedure z_NamedFramebufferTexture2DEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTexture2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture2DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_NamedFramebufferTexture2DEXT_ovr_0(framebuffer, attachment, textarget, texture, level);
private static procedure z_NamedFramebufferTexture3DEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTexture3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture3DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32) :=
z_NamedFramebufferTexture3DEXT_ovr_0(framebuffer, attachment, textarget, texture, level, zoffset);
private static procedure z_NamedFramebufferRenderbufferEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glNamedFramebufferRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferRenderbufferEXT(framebuffer: UInt32; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32) :=
z_NamedFramebufferRenderbufferEXT_ovr_0(framebuffer, attachment, _renderbuffertarget, renderbuffer);
private static procedure z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameterivEXT';
private static procedure z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0_anh00001(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0(framebuffer, attachment, pname, ¶ms[0]) else
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0_anh00001(framebuffer, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0(framebuffer, attachment, pname, ¶ms);
private static procedure z_GetNamedFramebufferAttachmentParameterivEXT_ovr_2(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferAttachmentParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_2(framebuffer, attachment, pname, ¶ms);
private static procedure z_GenerateTextureMipmapEXT_ovr_0(texture: UInt32; target: TextureTarget);
external 'opengl32.dll' name 'glGenerateTextureMipmapEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateTextureMipmapEXT(texture: UInt32; target: TextureTarget) :=
z_GenerateTextureMipmapEXT_ovr_0(texture, target);
private static procedure z_GenerateMultiTexMipmapEXT_ovr_0(texunit: TextureUnit; target: TextureTarget);
external 'opengl32.dll' name 'glGenerateMultiTexMipmapEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMultiTexMipmapEXT(texunit: TextureUnit; target: TextureTarget) :=
z_GenerateMultiTexMipmapEXT_ovr_0(texunit, target);
private static procedure z_FramebufferDrawBufferEXT_ovr_0(framebuffer: UInt32; mode: DrawBufferMode);
external 'opengl32.dll' name 'glFramebufferDrawBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBufferEXT(framebuffer: UInt32; mode: DrawBufferMode) :=
z_FramebufferDrawBufferEXT_ovr_0(framebuffer, mode);
private static procedure z_FramebufferDrawBuffersEXT_ovr_0(framebuffer: UInt32; n: Int32; var bufs: DrawBufferMode);
external 'opengl32.dll' name 'glFramebufferDrawBuffersEXT';
private static procedure z_FramebufferDrawBuffersEXT_ovr_0_anh0001(framebuffer: UInt32; n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glFramebufferDrawBuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; bufs: array of DrawBufferMode) :=
if (bufs<>nil) and (bufs.Length<>0) then
z_FramebufferDrawBuffersEXT_ovr_0(framebuffer, n, bufs[0]) else
z_FramebufferDrawBuffersEXT_ovr_0_anh0001(framebuffer, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; var bufs: DrawBufferMode) :=
z_FramebufferDrawBuffersEXT_ovr_0(framebuffer, n, bufs);
private static procedure z_FramebufferDrawBuffersEXT_ovr_2(framebuffer: UInt32; n: Int32; bufs: IntPtr);
external 'opengl32.dll' name 'glFramebufferDrawBuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; bufs: IntPtr) :=
z_FramebufferDrawBuffersEXT_ovr_2(framebuffer, n, bufs);
private static procedure z_FramebufferReadBufferEXT_ovr_0(framebuffer: UInt32; mode: ReadBufferMode);
external 'opengl32.dll' name 'glFramebufferReadBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferReadBufferEXT(framebuffer: UInt32; mode: ReadBufferMode) :=
z_FramebufferReadBufferEXT_ovr_0(framebuffer, mode);
private static procedure z_GetFramebufferParameterivEXT_ovr_0(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFramebufferParameterivEXT';
private static procedure z_GetFramebufferParameterivEXT_ovr_0_anh0001(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms[0]) else
z_GetFramebufferParameterivEXT_ovr_0_anh0001(framebuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32) :=
z_GetFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms);
private static procedure z_GetFramebufferParameterivEXT_ovr_2(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr) :=
z_GetFramebufferParameterivEXT_ovr_2(framebuffer, pname, ¶ms);
private static procedure z_NamedCopyBufferSubDataEXT_ovr_0(readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glNamedCopyBufferSubDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedCopyBufferSubDataEXT(readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_NamedCopyBufferSubDataEXT_ovr_0(readBuffer, writeBuffer, readOffset, writeOffset, size);
private static procedure z_NamedFramebufferTextureEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32) :=
z_NamedFramebufferTextureEXT_ovr_0(framebuffer, attachment, texture, level);
private static procedure z_NamedFramebufferTextureLayerEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glNamedFramebufferTextureLayerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureLayerEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32) :=
z_NamedFramebufferTextureLayerEXT_ovr_0(framebuffer, attachment, texture, level, layer);
private static procedure z_NamedFramebufferTextureFaceEXT_ovr_0(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget);
external 'opengl32.dll' name 'glNamedFramebufferTextureFaceEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureFaceEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget) :=
z_NamedFramebufferTextureFaceEXT_ovr_0(framebuffer, attachment, texture, level, face);
private static procedure z_TextureRenderbufferEXT_ovr_0(texture: UInt32; target: TextureTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glTextureRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureRenderbufferEXT(texture: UInt32; target: TextureTarget; renderbuffer: UInt32) :=
z_TextureRenderbufferEXT_ovr_0(texture, target, renderbuffer);
private static procedure z_MultiTexRenderbufferEXT_ovr_0(texunit: TextureUnit; target: TextureTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glMultiTexRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexRenderbufferEXT(texunit: TextureUnit; target: TextureTarget; renderbuffer: UInt32) :=
z_MultiTexRenderbufferEXT_ovr_0(texunit, target, renderbuffer);
private static procedure z_VertexArrayVertexOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; size: Int32; &type: VertexPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: VertexPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayVertexOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
private static procedure z_VertexArrayColorOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayColorOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayColorOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayColorOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
private static procedure z_VertexArrayEdgeFlagOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayEdgeFlagOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayEdgeFlagOffsetEXT(vaobj: UInt32; buffer: UInt32; stride: Int32; offset: IntPtr) :=
z_VertexArrayEdgeFlagOffsetEXT_ovr_0(vaobj, buffer, stride, offset);
private static procedure z_VertexArrayIndexOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; &type: IndexPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayIndexOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayIndexOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: IndexPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayIndexOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
private static procedure z_VertexArrayNormalOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; &type: NormalPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayNormalOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayNormalOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: NormalPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayNormalOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
private static procedure z_VertexArrayTexCoordOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayTexCoordOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayTexCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayTexCoordOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
private static procedure z_VertexArrayMultiTexCoordOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; texunit: DummyEnum; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayMultiTexCoordOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayMultiTexCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; texunit: DummyEnum; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayMultiTexCoordOffsetEXT_ovr_0(vaobj, buffer, texunit, size, &type, stride, offset);
private static procedure z_VertexArrayFogCoordOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; &type: FogCoordinatePointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayFogCoordOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayFogCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: FogCoordinatePointerType; stride: Int32; offset: IntPtr) :=
z_VertexArrayFogCoordOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
private static procedure z_VertexArraySecondaryColorOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArraySecondaryColorOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArraySecondaryColorOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr) :=
z_VertexArraySecondaryColorOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
private static procedure z_VertexArrayVertexAttribOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexAttribOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; offset: IntPtr) :=
z_VertexArrayVertexAttribOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, normalized, stride, offset);
private static procedure z_VertexArrayVertexAttribIOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexAttribIOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribIOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribType; stride: Int32; offset: IntPtr) :=
z_VertexArrayVertexAttribIOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, stride, offset);
private static procedure z_EnableVertexArrayEXT_ovr_0(vaobj: UInt32; &array: EnableCap);
external 'opengl32.dll' name 'glEnableVertexArrayEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayEXT(vaobj: UInt32; &array: EnableCap) :=
z_EnableVertexArrayEXT_ovr_0(vaobj, &array);
private static procedure z_DisableVertexArrayEXT_ovr_0(vaobj: UInt32; &array: EnableCap);
external 'opengl32.dll' name 'glDisableVertexArrayEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayEXT(vaobj: UInt32; &array: EnableCap) :=
z_DisableVertexArrayEXT_ovr_0(vaobj, &array);
private static procedure z_EnableVertexArrayAttribEXT_ovr_0(vaobj: UInt32; index: UInt32);
external 'opengl32.dll' name 'glEnableVertexArrayAttribEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayAttribEXT(vaobj: UInt32; index: UInt32) :=
z_EnableVertexArrayAttribEXT_ovr_0(vaobj, index);
private static procedure z_DisableVertexArrayAttribEXT_ovr_0(vaobj: UInt32; index: UInt32);
external 'opengl32.dll' name 'glDisableVertexArrayAttribEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayAttribEXT(vaobj: UInt32; index: UInt32) :=
z_DisableVertexArrayAttribEXT_ovr_0(vaobj, index);
private static procedure z_GetVertexArrayIntegervEXT_ovr_0(vaobj: UInt32; pname: VertexArrayPName; var param: Int32);
external 'opengl32.dll' name 'glGetVertexArrayIntegervEXT';
private static procedure z_GetVertexArrayIntegervEXT_ovr_0_anh0001(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIntegervEXT_ovr_0(vaobj, pname, param[0]) else
z_GetVertexArrayIntegervEXT_ovr_0_anh0001(vaobj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayIntegervEXT_ovr_0(vaobj, pname, param);
private static procedure z_GetVertexArrayIntegervEXT_ovr_2(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIntegervEXT_ovr_2(vaobj, pname, param);
private static procedure z_GetVertexArrayPointervEXT_ovr_0(vaobj: UInt32; pname: VertexArrayPName; var param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayPointervEXT';
private static procedure z_GetVertexArrayPointervEXT_ovr_0_anh0001(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; param: array of IntPtr) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayPointervEXT_ovr_0(vaobj, pname, param[0]) else
z_GetVertexArrayPointervEXT_ovr_0_anh0001(vaobj, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; var param: IntPtr) :=
z_GetVertexArrayPointervEXT_ovr_0(vaobj, pname, param);
private static procedure z_GetVertexArrayPointervEXT_ovr_2(vaobj: UInt32; pname: VertexArrayPName; param: pointer);
external 'opengl32.dll' name 'glGetVertexArrayPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; param: pointer) :=
z_GetVertexArrayPointervEXT_ovr_2(vaobj, pname, param);
private static procedure z_GetVertexArrayIntegeri_vEXT_ovr_0(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32);
external 'opengl32.dll' name 'glGetVertexArrayIntegeri_vEXT';
private static procedure z_GetVertexArrayIntegeri_vEXT_ovr_0_anh00001(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIntegeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int32) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayIntegeri_vEXT_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayIntegeri_vEXT_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32) :=
z_GetVertexArrayIntegeri_vEXT_ovr_0(vaobj, index, pname, param);
private static procedure z_GetVertexArrayIntegeri_vEXT_ovr_2(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayIntegeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr) :=
z_GetVertexArrayIntegeri_vEXT_ovr_2(vaobj, index, pname, param);
private static procedure z_GetVertexArrayPointeri_vEXT_ovr_0(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayPointeri_vEXT';
private static procedure z_GetVertexArrayPointeri_vEXT_ovr_0_anh00001(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
external 'opengl32.dll' name 'glGetVertexArrayPointeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of IntPtr) :=
if (param<>nil) and (param.Length<>0) then
z_GetVertexArrayPointeri_vEXT_ovr_0(vaobj, index, pname, param[0]) else
z_GetVertexArrayPointeri_vEXT_ovr_0_anh00001(vaobj, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: IntPtr) :=
z_GetVertexArrayPointeri_vEXT_ovr_0(vaobj, index, pname, param);
private static procedure z_GetVertexArrayPointeri_vEXT_ovr_2(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: pointer);
external 'opengl32.dll' name 'glGetVertexArrayPointeri_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: pointer) :=
z_GetVertexArrayPointeri_vEXT_ovr_2(vaobj, index, pname, param);
private static function z_MapNamedBufferRangeEXT_ovr_0(buffer: UInt32; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr;
external 'opengl32.dll' name 'glMapNamedBufferRangeEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferRangeEXT(buffer: UInt32; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
z_MapNamedBufferRangeEXT_ovr_0(buffer, offset, length, access);
private static procedure z_FlushMappedNamedBufferRangeEXT_ovr_0(buffer: UInt32; offset: IntPtr; length: IntPtr);
external 'opengl32.dll' name 'glFlushMappedNamedBufferRangeEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedNamedBufferRangeEXT(buffer: UInt32; offset: IntPtr; length: IntPtr) :=
z_FlushMappedNamedBufferRangeEXT_ovr_0(buffer, offset, length);
private static procedure z_NamedBufferStorageEXT_ovr_0(buffer: UInt32; size: IntPtr; data: IntPtr; flags: BufferStorageMask);
external 'opengl32.dll' name 'glNamedBufferStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageEXT(buffer: UInt32; size: IntPtr; data: IntPtr; flags: BufferStorageMask) :=
z_NamedBufferStorageEXT_ovr_0(buffer, size, data, flags);
private static procedure z_ClearNamedBufferDataEXT_ovr_0(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearNamedBufferDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferDataEXT(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferDataEXT_ovr_0(buffer, _internalformat, format, &type, data);
private static procedure z_ClearNamedBufferSubDataEXT_ovr_0(buffer: UInt32; internalformat: DummyEnum; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glClearNamedBufferSubDataEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferSubDataEXT(buffer: UInt32; internalformat: DummyEnum; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_ClearNamedBufferSubDataEXT_ovr_0(buffer, internalformat, offset, size, format, &type, data);
private static procedure z_NamedFramebufferParameteriEXT_ovr_0(framebuffer: UInt32; pname: FramebufferParameterName; param: Int32);
external 'opengl32.dll' name 'glNamedFramebufferParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferParameteriEXT(framebuffer: UInt32; pname: FramebufferParameterName; param: Int32) :=
z_NamedFramebufferParameteriEXT_ovr_0(framebuffer, pname, param);
private static procedure z_GetNamedFramebufferParameterivEXT_ovr_0(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterivEXT';
private static procedure z_GetNamedFramebufferParameterivEXT_ovr_0_anh0001(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms[0]) else
z_GetNamedFramebufferParameterivEXT_ovr_0_anh0001(framebuffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32) :=
z_GetNamedFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms);
private static procedure z_GetNamedFramebufferParameterivEXT_ovr_2(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedFramebufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr) :=
z_GetNamedFramebufferParameterivEXT_ovr_2(framebuffer, pname, ¶ms);
private static procedure z_ProgramUniform1dEXT_ovr_0(&program: UInt32; location: Int32; x: real);
external 'opengl32.dll' name 'glProgramUniform1dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dEXT(&program: UInt32; location: Int32; x: real) :=
z_ProgramUniform1dEXT_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2dEXT_ovr_0(&program: UInt32; location: Int32; x: real; y: real);
external 'opengl32.dll' name 'glProgramUniform2dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dEXT(&program: UInt32; location: Int32; x: real; y: real) :=
z_ProgramUniform2dEXT_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3dEXT_ovr_0(&program: UInt32; location: Int32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glProgramUniform3dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dEXT(&program: UInt32; location: Int32; x: real; y: real; z: real) :=
z_ProgramUniform3dEXT_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4dEXT_ovr_0(&program: UInt32; location: Int32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramUniform4dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dEXT(&program: UInt32; location: Int32; x: real; y: real; z: real; w: real) :=
z_ProgramUniform4dEXT_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform1dvEXT';
private static procedure z_ProgramUniform1dvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1dvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1dvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform1dvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1dvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform2dvEXT';
private static procedure z_ProgramUniform2dvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2dvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2dvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform2dvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2dvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform3dvEXT';
private static procedure z_ProgramUniform3dvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3dvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3dvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform3dvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3dvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: real);
external 'opengl32.dll' name 'glProgramUniform4dvEXT';
private static procedure z_ProgramUniform4dvEXT_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4dvEXT_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4dvEXT_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real) :=
z_ProgramUniform4dvEXT_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4dvEXT_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniformMatrix2dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2dvEXT';
private static procedure z_ProgramUniformMatrix2dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3dvEXT';
private static procedure z_ProgramUniformMatrix3dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4dvEXT';
private static procedure z_ProgramUniformMatrix4dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dvEXT';
private static procedure z_ProgramUniformMatrix2x3dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x3dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x3dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x3dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x3dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x3dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dvEXT';
private static procedure z_ProgramUniformMatrix2x4dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix2x4dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix2x4dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix2x4dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix2x4dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix2x4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix2x4dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dvEXT';
private static procedure z_ProgramUniformMatrix3x2dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x2dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x2dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x2dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x2dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x2dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dvEXT';
private static procedure z_ProgramUniformMatrix3x4dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix3x4dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix3x4dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix3x4dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix3x4dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix3x4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix3x4dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dvEXT';
private static procedure z_ProgramUniformMatrix4x2dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x2dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x2dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x2dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x2dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x2dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3dvEXT_ovr_0(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dvEXT';
private static procedure z_ProgramUniformMatrix4x3dvEXT_ovr_0_anh000001(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformMatrix4x3dvEXT_ovr_0(&program, location, count, transpose, value[0]) else
z_ProgramUniformMatrix4x3dvEXT_ovr_0_anh000001(&program, location, count, transpose, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real) :=
z_ProgramUniformMatrix4x3dvEXT_ovr_0(&program, location, count, transpose, value);
private static procedure z_ProgramUniformMatrix4x3dvEXT_ovr_2(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformMatrix4x3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr) :=
z_ProgramUniformMatrix4x3dvEXT_ovr_2(&program, location, count, transpose, value);
private static procedure z_TextureBufferRangeEXT_ovr_0(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glTextureBufferRangeEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferRangeEXT(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32; offset: IntPtr; size: IntPtr) :=
z_TextureBufferRangeEXT_ovr_0(texture, target, _internalformat, buffer, offset, size);
private static procedure z_TextureStorage1DEXT_ovr_0(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32);
external 'opengl32.dll' name 'glTextureStorage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage1DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32) :=
z_TextureStorage1DEXT_ovr_0(texture, target, levels, _internalformat, width);
private static procedure z_TextureStorage2DEXT_ovr_0(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glTextureStorage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_TextureStorage2DEXT_ovr_0(texture, target, levels, _internalformat, width, height);
private static procedure z_TextureStorage3DEXT_ovr_0(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glTextureStorage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32) :=
z_TextureStorage3DEXT_ovr_0(texture, target, levels, _internalformat, width, height, depth);
private static procedure z_TextureStorage2DMultisampleEXT_ovr_0(texture: UInt32; target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTextureStorage2DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DMultisampleEXT(texture: UInt32; target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage2DMultisampleEXT_ovr_0(texture, target, samples, _internalformat, width, height, fixedsamplelocations);
private static procedure z_TextureStorage3DMultisampleEXT_ovr_0(texture: UInt32; target: DummyEnum; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glTextureStorage3DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DMultisampleEXT(texture: UInt32; target: DummyEnum; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean) :=
z_TextureStorage3DMultisampleEXT_ovr_0(texture, target, samples, _internalformat, width, height, depth, fixedsamplelocations);
private static procedure z_VertexArrayBindVertexBufferEXT_ovr_0(vaobj: UInt32; bindingindex: UInt32; buffer: UInt32; offset: IntPtr; stride: Int32);
external 'opengl32.dll' name 'glVertexArrayBindVertexBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayBindVertexBufferEXT(vaobj: UInt32; bindingindex: UInt32; buffer: UInt32; offset: IntPtr; stride: Int32) :=
z_VertexArrayBindVertexBufferEXT_ovr_0(vaobj, bindingindex, buffer, offset, stride);
private static procedure z_VertexArrayVertexAttribFormatEXT_ovr_0(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexAttribFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32) :=
z_VertexArrayVertexAttribFormatEXT_ovr_0(vaobj, attribindex, size, &type, normalized, relativeoffset);
private static procedure z_VertexArrayVertexAttribIFormatEXT_ovr_0(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexAttribIFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribIFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32) :=
z_VertexArrayVertexAttribIFormatEXT_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
private static procedure z_VertexArrayVertexAttribLFormatEXT_ovr_0(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexAttribLFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribLFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32) :=
z_VertexArrayVertexAttribLFormatEXT_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
private static procedure z_VertexArrayVertexAttribBindingEXT_ovr_0(vaobj: UInt32; attribindex: UInt32; bindingindex: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexAttribBindingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribBindingEXT(vaobj: UInt32; attribindex: UInt32; bindingindex: UInt32) :=
z_VertexArrayVertexAttribBindingEXT_ovr_0(vaobj, attribindex, bindingindex);
private static procedure z_VertexArrayVertexBindingDivisorEXT_ovr_0(vaobj: UInt32; bindingindex: UInt32; divisor: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexBindingDivisorEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBindingDivisorEXT(vaobj: UInt32; bindingindex: UInt32; divisor: UInt32) :=
z_VertexArrayVertexBindingDivisorEXT_ovr_0(vaobj, bindingindex, divisor);
private static procedure z_VertexArrayVertexAttribLOffsetEXT_ovr_0(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32; offset: IntPtr);
external 'opengl32.dll' name 'glVertexArrayVertexAttribLOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribLOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32; offset: IntPtr) :=
z_VertexArrayVertexAttribLOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, stride, offset);
private static procedure z_TexturePageCommitmentEXT_ovr_0(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean);
external 'opengl32.dll' name 'glTexturePageCommitmentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexturePageCommitmentEXT(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean) :=
z_TexturePageCommitmentEXT_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
private static procedure z_VertexArrayVertexAttribDivisorEXT_ovr_0(vaobj: UInt32; index: UInt32; divisor: UInt32);
external 'opengl32.dll' name 'glVertexArrayVertexAttribDivisorEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribDivisorEXT(vaobj: UInt32; index: UInt32; divisor: UInt32) :=
z_VertexArrayVertexAttribDivisorEXT_ovr_0(vaobj, index, divisor);
end;
[PCUNotRestore]
glDrawBuffers2EXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ColorMaskIndexedEXT_ovr_0(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean);
external 'opengl32.dll' name 'glColorMaskIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMaskIndexedEXT(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean) :=
z_ColorMaskIndexedEXT_ovr_0(index, r, g, b, a);
private static procedure z_GetBooleanIndexedvEXT_ovr_0(target: BufferTargetARB; index: UInt32; var data: boolean);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
private static procedure z_GetBooleanIndexedvEXT_ovr_0_anh0001(target: BufferTargetARB; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetBooleanIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean) :=
z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetBooleanIndexedvEXT_ovr_2(target: BufferTargetARB; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
private static procedure z_GetIntegerIndexedvEXT_ovr_0(target: DummyEnum; index: UInt32; var data: Int32);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
private static procedure z_GetIntegerIndexedvEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetIntegerIndexedvEXT_ovr_0(target, index, data[0]) else
z_GetIntegerIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; var data: Int32) :=
z_GetIntegerIndexedvEXT_ovr_0(target, index, data);
private static procedure z_GetIntegerIndexedvEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerIndexedvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetIntegerIndexedvEXT_ovr_2(target, index, data);
private static procedure z_EnableIndexedEXT_ovr_0(target: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glEnableIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableIndexedEXT(target: EnableCap; index: UInt32) :=
z_EnableIndexedEXT_ovr_0(target, index);
private static procedure z_DisableIndexedEXT_ovr_0(target: EnableCap; index: UInt32);
external 'opengl32.dll' name 'glDisableIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableIndexedEXT(target: EnableCap; index: UInt32) :=
z_DisableIndexedEXT_ovr_0(target, index);
private static function z_IsEnabledIndexedEXT_ovr_0(target: EnableCap; index: UInt32): boolean;
external 'opengl32.dll' name 'glIsEnabledIndexedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabledIndexedEXT(target: EnableCap; index: UInt32): boolean :=
z_IsEnabledIndexedEXT_ovr_0(target, index);
end;
[PCUNotRestore]
glDrawInstancedEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawArraysInstancedEXT_ovr_0(mode: PrimitiveType; start: Int32; count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glDrawArraysInstancedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedEXT(mode: PrimitiveType; start: Int32; count: Int32; primcount: Int32) :=
z_DrawArraysInstancedEXT_ovr_0(mode, start, count, primcount);
private static procedure z_DrawElementsInstancedEXT_ovr_0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glDrawElementsInstancedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedEXT(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32) :=
z_DrawElementsInstancedEXT_ovr_0(mode, count, &type, indices, primcount);
end;
[PCUNotRestore]
glDrawRangeElementsEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawRangeElementsEXT_ovr_0(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr);
external 'opengl32.dll' name 'glDrawRangeElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementsEXT(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr) :=
z_DrawRangeElementsEXT_ovr_0(mode, start, &end, count, &type, indices);
end;
[PCUNotRestore]
glExternalBufferEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BufferStorageExternalEXT_ovr_0(target: DummyEnum; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask);
external 'opengl32.dll' name 'glBufferStorageExternalEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageExternalEXT(target: DummyEnum; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask) :=
z_BufferStorageExternalEXT_ovr_0(target, offset, size, clientBuffer, flags);
private static procedure z_NamedBufferStorageExternalEXT_ovr_0(buffer: UInt32; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask);
external 'opengl32.dll' name 'glNamedBufferStorageExternalEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageExternalEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask) :=
z_NamedBufferStorageExternalEXT_ovr_0(buffer, offset, size, clientBuffer, flags);
end;
[PCUNotRestore]
glFogCoordEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FogCoordfEXT_ovr_0(coord: single);
external 'opengl32.dll' name 'glFogCoordfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfEXT(coord: single) :=
z_FogCoordfEXT_ovr_0(coord);
private static procedure z_FogCoordfvEXT_ovr_0(var coord: single);
external 'opengl32.dll' name 'glFogCoordfvEXT';
private static procedure z_FogCoordfvEXT_ovr_0_anh01(coord: IntPtr);
external 'opengl32.dll' name 'glFogCoordfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(coord: array of single) :=
if (coord<>nil) and (coord.Length<>0) then
z_FogCoordfvEXT_ovr_0(coord[0]) else
z_FogCoordfvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(var coord: single) :=
z_FogCoordfvEXT_ovr_0(coord);
private static procedure z_FogCoordfvEXT_ovr_2(coord: IntPtr);
external 'opengl32.dll' name 'glFogCoordfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(coord: IntPtr) :=
z_FogCoordfvEXT_ovr_2(coord);
private static procedure z_FogCoorddEXT_ovr_0(coord: real);
external 'opengl32.dll' name 'glFogCoorddEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddEXT(coord: real) :=
z_FogCoorddEXT_ovr_0(coord);
private static procedure z_FogCoorddvEXT_ovr_0(var coord: real);
external 'opengl32.dll' name 'glFogCoorddvEXT';
private static procedure z_FogCoorddvEXT_ovr_0_anh01(coord: IntPtr);
external 'opengl32.dll' name 'glFogCoorddvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(coord: array of real) :=
if (coord<>nil) and (coord.Length<>0) then
z_FogCoorddvEXT_ovr_0(coord[0]) else
z_FogCoorddvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(var coord: real) :=
z_FogCoorddvEXT_ovr_0(coord);
private static procedure z_FogCoorddvEXT_ovr_2(coord: IntPtr);
external 'opengl32.dll' name 'glFogCoorddvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(coord: IntPtr) :=
z_FogCoorddvEXT_ovr_2(coord);
private static procedure z_FogCoordPointerEXT_ovr_0(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glFogCoordPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerEXT(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr) :=
z_FogCoordPointerEXT_ovr_0(&type, stride, pointer);
end;
[PCUNotRestore]
glFramebufferBlitEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlitFramebufferEXT_ovr_0(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter);
external 'opengl32.dll' name 'glBlitFramebufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlitFramebufferEXT(srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: BlitFramebufferFilter) :=
z_BlitFramebufferEXT_ovr_0(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
[PCUNotRestore]
glFramebufferMultisampleEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RenderbufferStorageMultisampleEXT_ovr_0(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorageMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleEXT(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageMultisampleEXT_ovr_0(target, samples, _internalformat, width, height);
end;
[PCUNotRestore]
glFramebufferObjectEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_IsRenderbufferEXT_ovr_0(renderbuffer: UInt32): boolean;
external 'opengl32.dll' name 'glIsRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsRenderbufferEXT(renderbuffer: UInt32): boolean :=
z_IsRenderbufferEXT_ovr_0(renderbuffer);
private static procedure z_BindRenderbufferEXT_ovr_0(target: RenderbufferTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glBindRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindRenderbufferEXT(target: RenderbufferTarget; renderbuffer: UInt32) :=
z_BindRenderbufferEXT_ovr_0(target, renderbuffer);
private static procedure z_DeleteRenderbuffersEXT_ovr_0(n: Int32; var renderbuffers: UInt32);
external 'opengl32.dll' name 'glDeleteRenderbuffersEXT';
private static procedure z_DeleteRenderbuffersEXT_ovr_0_anh001(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteRenderbuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_DeleteRenderbuffersEXT_ovr_0(n, renderbuffers[0]) else
z_DeleteRenderbuffersEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; var renderbuffers: UInt32) :=
z_DeleteRenderbuffersEXT_ovr_0(n, renderbuffers);
private static procedure z_DeleteRenderbuffersEXT_ovr_2(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteRenderbuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; renderbuffers: IntPtr) :=
z_DeleteRenderbuffersEXT_ovr_2(n, renderbuffers);
private static procedure z_GenRenderbuffersEXT_ovr_0(n: Int32; var renderbuffers: UInt32);
external 'opengl32.dll' name 'glGenRenderbuffersEXT';
private static procedure z_GenRenderbuffersEXT_ovr_0_anh001(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glGenRenderbuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; renderbuffers: array of UInt32) :=
if (renderbuffers<>nil) and (renderbuffers.Length<>0) then
z_GenRenderbuffersEXT_ovr_0(n, renderbuffers[0]) else
z_GenRenderbuffersEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; var renderbuffers: UInt32) :=
z_GenRenderbuffersEXT_ovr_0(n, renderbuffers);
private static procedure z_GenRenderbuffersEXT_ovr_2(n: Int32; renderbuffers: IntPtr);
external 'opengl32.dll' name 'glGenRenderbuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; renderbuffers: IntPtr) :=
z_GenRenderbuffersEXT_ovr_2(n, renderbuffers);
private static procedure z_RenderbufferStorageEXT_ovr_0(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorageEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageEXT(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageEXT_ovr_0(target, _internalformat, width, height);
private static procedure z_GetRenderbufferParameterivEXT_ovr_0(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetRenderbufferParameterivEXT';
private static procedure z_GetRenderbufferParameterivEXT_ovr_0_anh0001(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetRenderbufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetRenderbufferParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetRenderbufferParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32) :=
z_GetRenderbufferParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetRenderbufferParameterivEXT_ovr_2(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetRenderbufferParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr) :=
z_GetRenderbufferParameterivEXT_ovr_2(target, pname, ¶ms);
private static function z_IsFramebufferEXT_ovr_0(framebuffer: UInt32): boolean;
external 'opengl32.dll' name 'glIsFramebufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFramebufferEXT(framebuffer: UInt32): boolean :=
z_IsFramebufferEXT_ovr_0(framebuffer);
private static procedure z_BindFramebufferEXT_ovr_0(target: FramebufferTarget; framebuffer: UInt32);
external 'opengl32.dll' name 'glBindFramebufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFramebufferEXT(target: FramebufferTarget; framebuffer: UInt32) :=
z_BindFramebufferEXT_ovr_0(target, framebuffer);
private static procedure z_DeleteFramebuffersEXT_ovr_0(n: Int32; var framebuffers: UInt32);
external 'opengl32.dll' name 'glDeleteFramebuffersEXT';
private static procedure z_DeleteFramebuffersEXT_ovr_0_anh001(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteFramebuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_DeleteFramebuffersEXT_ovr_0(n, framebuffers[0]) else
z_DeleteFramebuffersEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; var framebuffers: UInt32) :=
z_DeleteFramebuffersEXT_ovr_0(n, framebuffers);
private static procedure z_DeleteFramebuffersEXT_ovr_2(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glDeleteFramebuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; framebuffers: IntPtr) :=
z_DeleteFramebuffersEXT_ovr_2(n, framebuffers);
private static procedure z_GenFramebuffersEXT_ovr_0(n: Int32; var framebuffers: UInt32);
external 'opengl32.dll' name 'glGenFramebuffersEXT';
private static procedure z_GenFramebuffersEXT_ovr_0_anh001(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glGenFramebuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; framebuffers: array of UInt32) :=
if (framebuffers<>nil) and (framebuffers.Length<>0) then
z_GenFramebuffersEXT_ovr_0(n, framebuffers[0]) else
z_GenFramebuffersEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; var framebuffers: UInt32) :=
z_GenFramebuffersEXT_ovr_0(n, framebuffers);
private static procedure z_GenFramebuffersEXT_ovr_2(n: Int32; framebuffers: IntPtr);
external 'opengl32.dll' name 'glGenFramebuffersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; framebuffers: IntPtr) :=
z_GenFramebuffersEXT_ovr_2(n, framebuffers);
private static function z_CheckFramebufferStatusEXT_ovr_0(target: FramebufferTarget): FramebufferStatus;
external 'opengl32.dll' name 'glCheckFramebufferStatusEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckFramebufferStatusEXT(target: FramebufferTarget): FramebufferStatus :=
z_CheckFramebufferStatusEXT_ovr_0(target);
private static procedure z_FramebufferTexture1DEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTexture1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture1DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture1DEXT_ovr_0(target, attachment, textarget, texture, level);
private static procedure z_FramebufferTexture2DEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTexture2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture2DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32) :=
z_FramebufferTexture2DEXT_ovr_0(target, attachment, textarget, texture, level);
private static procedure z_FramebufferTexture3DEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32);
external 'opengl32.dll' name 'glFramebufferTexture3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture3DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32) :=
z_FramebufferTexture3DEXT_ovr_0(target, attachment, textarget, texture, level, zoffset);
private static procedure z_FramebufferRenderbufferEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glFramebufferRenderbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferRenderbufferEXT(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32) :=
z_FramebufferRenderbufferEXT_ovr_0(target, attachment, _renderbuffertarget, renderbuffer);
private static procedure z_GetFramebufferAttachmentParameterivEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameterivEXT';
private static procedure z_GetFramebufferAttachmentParameterivEXT_ovr_0_anh00001(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferAttachmentParameterivEXT_ovr_0(target, attachment, pname, ¶ms[0]) else
z_GetFramebufferAttachmentParameterivEXT_ovr_0_anh00001(target, attachment, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferAttachmentParameterivEXT_ovr_0(target, attachment, pname, ¶ms);
private static procedure z_GetFramebufferAttachmentParameterivEXT_ovr_2(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferAttachmentParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferAttachmentParameterivEXT_ovr_2(target, attachment, pname, ¶ms);
private static procedure z_GenerateMipmapEXT_ovr_0(target: TextureTarget);
external 'opengl32.dll' name 'glGenerateMipmapEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMipmapEXT(target: TextureTarget) :=
z_GenerateMipmapEXT_ovr_0(target);
end;
[PCUNotRestore]
glGeometryShader4EXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramParameteriEXT_ovr_0(&program: UInt32; pname: ProgramParameterPName; value: Int32);
external 'opengl32.dll' name 'glProgramParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteriEXT(&program: UInt32; pname: ProgramParameterPName; value: Int32) :=
z_ProgramParameteriEXT_ovr_0(&program, pname, value);
end;
[PCUNotRestore]
glGpuProgramParametersEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramEnvParameters4fvEXT_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramEnvParameters4fvEXT';
private static procedure z_ProgramEnvParameters4fvEXT_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameters4fvEXT_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramEnvParameters4fvEXT_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single) :=
z_ProgramEnvParameters4fvEXT_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramEnvParameters4fvEXT_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramEnvParameters4fvEXT_ovr_2(target, index, count, ¶ms);
private static procedure z_ProgramLocalParameters4fvEXT_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramLocalParameters4fvEXT';
private static procedure z_ProgramLocalParameters4fvEXT_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameters4fvEXT_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramLocalParameters4fvEXT_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single) :=
z_ProgramLocalParameters4fvEXT_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramLocalParameters4fvEXT_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameters4fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramLocalParameters4fvEXT_ovr_2(target, index, count, ¶ms);
end;
[PCUNotRestore]
glGpuShader4EXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetUniformuivEXT_ovr_0(&program: UInt32; location: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetUniformuivEXT';
private static procedure z_GetUniformuivEXT_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformuivEXT_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformuivEXT_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; var ¶ms: UInt32) :=
z_GetUniformuivEXT_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformuivEXT_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformuivEXT_ovr_2(&program, location, ¶ms);
private static procedure z_BindFragDataLocationEXT_ovr_0(&program: UInt32; color: UInt32; name: IntPtr);
external 'opengl32.dll' name 'glBindFragDataLocationEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationEXT(&program: UInt32; color: UInt32; name: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_BindFragDataLocationEXT_ovr_0(&program, color, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragDataLocationEXT(&program: UInt32; color: UInt32; name: IntPtr) :=
z_BindFragDataLocationEXT_ovr_0(&program, color, name);
private static function z_GetFragDataLocationEXT_ovr_0(&program: UInt32; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetFragDataLocationEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataLocationEXT(&program: UInt32; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetFragDataLocationEXT_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetFragDataLocationEXT(&program: UInt32; name: IntPtr): Int32 :=
z_GetFragDataLocationEXT_ovr_0(&program, name);
private static procedure z_Uniform1uiEXT_ovr_0(location: Int32; v0: UInt32);
external 'opengl32.dll' name 'glUniform1uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiEXT(location: Int32; v0: UInt32) :=
z_Uniform1uiEXT_ovr_0(location, v0);
private static procedure z_Uniform2uiEXT_ovr_0(location: Int32; v0: UInt32; v1: UInt32);
external 'opengl32.dll' name 'glUniform2uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiEXT(location: Int32; v0: UInt32; v1: UInt32) :=
z_Uniform2uiEXT_ovr_0(location, v0, v1);
private static procedure z_Uniform3uiEXT_ovr_0(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32);
external 'opengl32.dll' name 'glUniform3uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiEXT(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32) :=
z_Uniform3uiEXT_ovr_0(location, v0, v1, v2);
private static procedure z_Uniform4uiEXT_ovr_0(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32);
external 'opengl32.dll' name 'glUniform4uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiEXT(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32) :=
z_Uniform4uiEXT_ovr_0(location, v0, v1, v2, v3);
private static procedure z_Uniform1uivEXT_ovr_0(location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glUniform1uivEXT';
private static procedure z_Uniform1uivEXT_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1uivEXT_ovr_0(location, count, value[0]) else
z_Uniform1uivEXT_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform1uivEXT_ovr_0(location, count, value);
private static procedure z_Uniform1uivEXT_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1uivEXT_ovr_2(location, count, value);
private static procedure z_Uniform2uivEXT_ovr_0(location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glUniform2uivEXT';
private static procedure z_Uniform2uivEXT_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2uivEXT_ovr_0(location, count, value[0]) else
z_Uniform2uivEXT_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform2uivEXT_ovr_0(location, count, value);
private static procedure z_Uniform2uivEXT_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2uivEXT_ovr_2(location, count, value);
private static procedure z_Uniform3uivEXT_ovr_0(location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glUniform3uivEXT';
private static procedure z_Uniform3uivEXT_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3uivEXT_ovr_0(location, count, value[0]) else
z_Uniform3uivEXT_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform3uivEXT_ovr_0(location, count, value);
private static procedure z_Uniform3uivEXT_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3uivEXT_ovr_2(location, count, value);
private static procedure z_Uniform4uivEXT_ovr_0(location: Int32; count: Int32; var value: UInt32);
external 'opengl32.dll' name 'glUniform4uivEXT';
private static procedure z_Uniform4uivEXT_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; value: array of UInt32) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4uivEXT_ovr_0(location, count, value[0]) else
z_Uniform4uivEXT_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; var value: UInt32) :=
z_Uniform4uivEXT_ovr_0(location, count, value);
private static procedure z_Uniform4uivEXT_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4uivEXT_ovr_2(location, count, value);
end;
[PCUNotRestore]
glHistogramEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetHistogramEXT_ovr_0(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
external 'opengl32.dll' name 'glGetHistogramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramEXT(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr) :=
z_GetHistogramEXT_ovr_0(target, reset, format, &type, values);
private static procedure z_GetHistogramParameterfvEXT_ovr_0(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetHistogramParameterfvEXT';
private static procedure z_GetHistogramParameterfvEXT_ovr_0_anh0001(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetHistogramParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetHistogramParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single) :=
z_GetHistogramParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetHistogramParameterfvEXT_ovr_2(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr) :=
z_GetHistogramParameterfvEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetHistogramParameterivEXT_ovr_0(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetHistogramParameterivEXT';
private static procedure z_GetHistogramParameterivEXT_ovr_0_anh0001(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetHistogramParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetHistogramParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32) :=
z_GetHistogramParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetHistogramParameterivEXT_ovr_2(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr) :=
z_GetHistogramParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetMinmaxEXT_ovr_0(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxEXT(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr) :=
z_GetMinmaxEXT_ovr_0(target, reset, format, &type, values);
private static procedure z_GetMinmaxParameterfvEXT_ovr_0(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single);
external 'opengl32.dll' name 'glGetMinmaxParameterfvEXT';
private static procedure z_GetMinmaxParameterfvEXT_ovr_0_anh0001(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMinmaxParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetMinmaxParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single) :=
z_GetMinmaxParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetMinmaxParameterfvEXT_ovr_2(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr) :=
z_GetMinmaxParameterfvEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetMinmaxParameterivEXT_ovr_0(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMinmaxParameterivEXT';
private static procedure z_GetMinmaxParameterivEXT_ovr_0_anh0001(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMinmaxParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetMinmaxParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32) :=
z_GetMinmaxParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetMinmaxParameterivEXT_ovr_2(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMinmaxParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr) :=
z_GetMinmaxParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_HistogramEXT_ovr_0(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean);
external 'opengl32.dll' name 'glHistogramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure HistogramEXT(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean) :=
z_HistogramEXT_ovr_0(target, width, _internalformat, sink);
private static procedure z_MinmaxEXT_ovr_0(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean);
external 'opengl32.dll' name 'glMinmaxEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinmaxEXT(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean) :=
z_MinmaxEXT_ovr_0(target, _internalformat, sink);
private static procedure z_ResetHistogramEXT_ovr_0(target: HistogramTargetEXT);
external 'opengl32.dll' name 'glResetHistogramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetHistogramEXT(target: HistogramTargetEXT) :=
z_ResetHistogramEXT_ovr_0(target);
private static procedure z_ResetMinmaxEXT_ovr_0(target: MinmaxTargetEXT);
external 'opengl32.dll' name 'glResetMinmaxEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetMinmaxEXT(target: MinmaxTargetEXT) :=
z_ResetMinmaxEXT_ovr_0(target);
end;
[PCUNotRestore]
glIndexFuncEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_IndexFuncEXT_ovr_0(func: IndexFunctionEXT; ref: single);
external 'opengl32.dll' name 'glIndexFuncEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexFuncEXT(func: IndexFunctionEXT; ref: single) :=
z_IndexFuncEXT_ovr_0(func, ref);
end;
[PCUNotRestore]
glIndexMaterialEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_IndexMaterialEXT_ovr_0(face: MaterialFace; mode: IndexMaterialParameterEXT);
external 'opengl32.dll' name 'glIndexMaterialEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexMaterialEXT(face: MaterialFace; mode: IndexMaterialParameterEXT) :=
z_IndexMaterialEXT_ovr_0(face, mode);
end;
[PCUNotRestore]
glLightTextureEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ApplyTextureEXT_ovr_0(mode: LightTextureModeEXT);
external 'opengl32.dll' name 'glApplyTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ApplyTextureEXT(mode: LightTextureModeEXT) :=
z_ApplyTextureEXT_ovr_0(mode);
private static procedure z_TextureLightEXT_ovr_0(pname: LightTexturePNameEXT);
external 'opengl32.dll' name 'glTextureLightEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureLightEXT(pname: LightTexturePNameEXT) :=
z_TextureLightEXT_ovr_0(pname);
private static procedure z_TextureMaterialEXT_ovr_0(face: MaterialFace; mode: MaterialParameter);
external 'opengl32.dll' name 'glTextureMaterialEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureMaterialEXT(face: MaterialFace; mode: MaterialParameter) :=
z_TextureMaterialEXT_ovr_0(face, mode);
end;
[PCUNotRestore]
glMemoryObjectEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetUnsignedBytevEXT_ovr_0(pname: GetPName; var data: Byte);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
private static procedure z_GetUnsignedBytevEXT_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: array of Byte) :=
if (data<>nil) and (data.Length<>0) then
z_GetUnsignedBytevEXT_ovr_0(pname, data[0]) else
z_GetUnsignedBytevEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; var data: Byte) :=
z_GetUnsignedBytevEXT_ovr_0(pname, data);
private static procedure z_GetUnsignedBytevEXT_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: IntPtr) :=
z_GetUnsignedBytevEXT_ovr_2(pname, data);
private static procedure z_GetUnsignedBytei_vEXT_ovr_0(target: DummyEnum; index: UInt32; var data: Byte);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
private static procedure z_GetUnsignedBytei_vEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: array of Byte) :=
if (data<>nil) and (data.Length<>0) then
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data[0]) else
z_GetUnsignedBytei_vEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; var data: Byte) :=
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data);
private static procedure z_GetUnsignedBytei_vEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetUnsignedBytei_vEXT_ovr_2(target, index, data);
private static procedure z_DeleteMemoryObjectsEXT_ovr_0(n: Int32; var memoryObjects: UInt32);
external 'opengl32.dll' name 'glDeleteMemoryObjectsEXT';
private static procedure z_DeleteMemoryObjectsEXT_ovr_0_anh001(n: Int32; memoryObjects: IntPtr);
external 'opengl32.dll' name 'glDeleteMemoryObjectsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; memoryObjects: array of UInt32) :=
if (memoryObjects<>nil) and (memoryObjects.Length<>0) then
z_DeleteMemoryObjectsEXT_ovr_0(n, memoryObjects[0]) else
z_DeleteMemoryObjectsEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; var memoryObjects: UInt32) :=
z_DeleteMemoryObjectsEXT_ovr_0(n, memoryObjects);
private static procedure z_DeleteMemoryObjectsEXT_ovr_2(n: Int32; memoryObjects: IntPtr);
external 'opengl32.dll' name 'glDeleteMemoryObjectsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; memoryObjects: IntPtr) :=
z_DeleteMemoryObjectsEXT_ovr_2(n, memoryObjects);
private static function z_IsMemoryObjectEXT_ovr_0(memoryObject: UInt32): boolean;
external 'opengl32.dll' name 'glIsMemoryObjectEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsMemoryObjectEXT(memoryObject: UInt32): boolean :=
z_IsMemoryObjectEXT_ovr_0(memoryObject);
private static procedure z_CreateMemoryObjectsEXT_ovr_0(n: Int32; var memoryObjects: UInt32);
external 'opengl32.dll' name 'glCreateMemoryObjectsEXT';
private static procedure z_CreateMemoryObjectsEXT_ovr_0_anh001(n: Int32; memoryObjects: IntPtr);
external 'opengl32.dll' name 'glCreateMemoryObjectsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; memoryObjects: array of UInt32) :=
if (memoryObjects<>nil) and (memoryObjects.Length<>0) then
z_CreateMemoryObjectsEXT_ovr_0(n, memoryObjects[0]) else
z_CreateMemoryObjectsEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; var memoryObjects: UInt32) :=
z_CreateMemoryObjectsEXT_ovr_0(n, memoryObjects);
private static procedure z_CreateMemoryObjectsEXT_ovr_2(n: Int32; memoryObjects: IntPtr);
external 'opengl32.dll' name 'glCreateMemoryObjectsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; memoryObjects: IntPtr) :=
z_CreateMemoryObjectsEXT_ovr_2(n, memoryObjects);
private static procedure z_MemoryObjectParameterivEXT_ovr_0(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glMemoryObjectParameterivEXT';
private static procedure z_MemoryObjectParameterivEXT_ovr_0_anh0001(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMemoryObjectParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms[0]) else
z_MemoryObjectParameterivEXT_ovr_0_anh0001(memoryObject, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32) :=
z_MemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms);
private static procedure z_MemoryObjectParameterivEXT_ovr_2(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMemoryObjectParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr) :=
z_MemoryObjectParameterivEXT_ovr_2(memoryObject, pname, ¶ms);
private static procedure z_GetMemoryObjectParameterivEXT_ovr_0(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMemoryObjectParameterivEXT';
private static procedure z_GetMemoryObjectParameterivEXT_ovr_0_anh0001(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMemoryObjectParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms[0]) else
z_GetMemoryObjectParameterivEXT_ovr_0_anh0001(memoryObject, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32) :=
z_GetMemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms);
private static procedure z_GetMemoryObjectParameterivEXT_ovr_2(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMemoryObjectParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr) :=
z_GetMemoryObjectParameterivEXT_ovr_2(memoryObject, pname, ¶ms);
private static procedure z_TexStorageMem2DEXT_ovr_0(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexStorageMem2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem2DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64) :=
z_TexStorageMem2DEXT_ovr_0(target, levels, internalFormat, width, height, memory, offset);
private static procedure z_TexStorageMem2DMultisampleEXT_ovr_0(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexStorageMem2DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem2DMultisampleEXT(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64) :=
z_TexStorageMem2DMultisampleEXT_ovr_0(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
private static procedure z_TexStorageMem3DEXT_ovr_0(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexStorageMem3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem3DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64) :=
z_TexStorageMem3DEXT_ovr_0(target, levels, internalFormat, width, height, depth, memory, offset);
private static procedure z_TexStorageMem3DMultisampleEXT_ovr_0(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexStorageMem3DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem3DMultisampleEXT(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64) :=
z_TexStorageMem3DMultisampleEXT_ovr_0(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
private static procedure z_BufferStorageMemEXT_ovr_0(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glBufferStorageMemEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageMemEXT(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64) :=
z_BufferStorageMemEXT_ovr_0(target, size, memory, offset);
private static procedure z_TextureStorageMem2DEXT_ovr_0(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureStorageMem2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem2DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64) :=
z_TextureStorageMem2DEXT_ovr_0(texture, levels, internalFormat, width, height, memory, offset);
private static procedure z_TextureStorageMem2DMultisampleEXT_ovr_0(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureStorageMem2DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem2DMultisampleEXT(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64) :=
z_TextureStorageMem2DMultisampleEXT_ovr_0(texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
private static procedure z_TextureStorageMem3DEXT_ovr_0(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureStorageMem3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem3DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64) :=
z_TextureStorageMem3DEXT_ovr_0(texture, levels, internalFormat, width, height, depth, memory, offset);
private static procedure z_TextureStorageMem3DMultisampleEXT_ovr_0(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureStorageMem3DMultisampleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem3DMultisampleEXT(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64) :=
z_TextureStorageMem3DMultisampleEXT_ovr_0(texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
private static procedure z_NamedBufferStorageMemEXT_ovr_0(buffer: UInt32; size: IntPtr; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glNamedBufferStorageMemEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageMemEXT(buffer: UInt32; size: IntPtr; memory: UInt32; offset: UInt64) :=
z_NamedBufferStorageMemEXT_ovr_0(buffer, size, memory, offset);
private static procedure z_TexStorageMem1DEXT_ovr_0(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexStorageMem1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem1DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64) :=
z_TexStorageMem1DEXT_ovr_0(target, levels, internalFormat, width, memory, offset);
private static procedure z_TextureStorageMem1DEXT_ovr_0(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureStorageMem1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem1DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64) :=
z_TextureStorageMem1DEXT_ovr_0(texture, levels, internalFormat, width, memory, offset);
end;
[PCUNotRestore]
glMemoryObjectFdEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ImportMemoryFdEXT_ovr_0(memory: UInt32; size: UInt64; handleType: ExternalHandleType; fd: Int32);
external 'opengl32.dll' name 'glImportMemoryFdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryFdEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; fd: Int32) :=
z_ImportMemoryFdEXT_ovr_0(memory, size, handleType, fd);
end;
[PCUNotRestore]
glMemoryObjectWin32EXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ImportMemoryWin32HandleEXT_ovr_0(memory: UInt32; size: UInt64; handleType: ExternalHandleType; handle: IntPtr);
external 'opengl32.dll' name 'glImportMemoryWin32HandleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryWin32HandleEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; handle: IntPtr) :=
z_ImportMemoryWin32HandleEXT_ovr_0(memory, size, handleType, handle);
private static procedure z_ImportMemoryWin32NameEXT_ovr_0(memory: UInt32; size: UInt64; handleType: ExternalHandleType; name: IntPtr);
external 'opengl32.dll' name 'glImportMemoryWin32NameEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryWin32NameEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; name: IntPtr) :=
z_ImportMemoryWin32NameEXT_ovr_0(memory, size, handleType, name);
end;
[PCUNotRestore]
glMultiDrawArraysEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysEXT_ovr_0(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
private static procedure z_MultiDrawArraysEXT_ovr_0_anh00100(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
private static procedure z_MultiDrawArraysEXT_ovr_0_anh00010(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
private static procedure z_MultiDrawArraysEXT_ovr_0_anh00110(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArraysEXT_ovr_0(mode, first[0], count[0], primcount) else
z_MultiDrawArraysEXT_ovr_0_anh00010(mode, first[0], IntPtr.Zero, primcount) else
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArraysEXT_ovr_0_anh00100(mode, IntPtr.Zero, count[0], primcount) else
z_MultiDrawArraysEXT_ovr_0_anh00110(mode, IntPtr.Zero, IntPtr.Zero, primcount);
private static procedure z_MultiDrawArraysEXT_ovr_1_anh00100(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawArraysEXT_ovr_0(mode, first[0], count, primcount) else
z_MultiDrawArraysEXT_ovr_0_anh00100(mode, IntPtr.Zero, count, primcount);
private static procedure z_MultiDrawArraysEXT_ovr_2(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
private static procedure z_MultiDrawArraysEXT_ovr_2_anh00100(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiDrawArraysEXT_ovr_2(mode, first[0], count, primcount) else
z_MultiDrawArraysEXT_ovr_2_anh00100(mode, IntPtr.Zero, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArraysEXT_ovr_0(mode, first, count[0], primcount) else
z_MultiDrawArraysEXT_ovr_0_anh00010(mode, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32) :=
z_MultiDrawArraysEXT_ovr_0(mode, first, count, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32) :=
z_MultiDrawArraysEXT_ovr_2(mode, first, count, primcount);
private static procedure z_MultiDrawArraysEXT_ovr_6(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
private static procedure z_MultiDrawArraysEXT_ovr_6_anh00010(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawArraysEXT_ovr_6(mode, first, count[0], primcount) else
z_MultiDrawArraysEXT_ovr_6_anh00010(mode, first, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32) :=
z_MultiDrawArraysEXT_ovr_6(mode, first, count, primcount);
private static procedure z_MultiDrawArraysEXT_ovr_8(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32) :=
z_MultiDrawArraysEXT_ovr_8(mode, first, count, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_0(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
private static procedure z_MultiDrawElementsEXT_ovr_0_anh001000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
private static procedure z_MultiDrawElementsEXT_ovr_0_anh000010(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
private static procedure z_MultiDrawElementsEXT_ovr_0_anh001010(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsEXT_ovr_0(mode, count[0], &type, indices[0], primcount) else
z_MultiDrawElementsEXT_ovr_0_anh000010(mode, count[0], &type, IntPtr.Zero, primcount) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsEXT_ovr_0_anh001000(mode, IntPtr.Zero, &type, indices[0], primcount) else
z_MultiDrawElementsEXT_ovr_0_anh001010(mode, IntPtr.Zero, &type, IntPtr.Zero, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_1_anh001000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsEXT_ovr_0(mode, count[0], &type, indices, primcount) else
z_MultiDrawElementsEXT_ovr_0_anh001000(mode, IntPtr.Zero, &type, indices, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_2(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
private static procedure z_MultiDrawElementsEXT_ovr_2_anh001000(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiDrawElementsEXT_ovr_2(mode, count[0], &type, indices, primcount) else
z_MultiDrawElementsEXT_ovr_2_anh001000(mode, IntPtr.Zero, &type, indices, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_3_anh000010(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsEXT_ovr_0(mode, count, &type, indices[0], primcount) else
z_MultiDrawElementsEXT_ovr_0_anh000010(mode, count, &type, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32) :=
z_MultiDrawElementsEXT_ovr_0(mode, count, &type, indices, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32) :=
z_MultiDrawElementsEXT_ovr_2(mode, count, &type, indices, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_6(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
private static procedure z_MultiDrawElementsEXT_ovr_6_anh000010(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiDrawElementsEXT_ovr_6(mode, count, &type, indices[0], primcount) else
z_MultiDrawElementsEXT_ovr_6_anh000010(mode, count, &type, IntPtr.Zero, primcount);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32) :=
z_MultiDrawElementsEXT_ovr_6(mode, count, &type, indices, primcount);
private static procedure z_MultiDrawElementsEXT_ovr_8(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32) :=
z_MultiDrawElementsEXT_ovr_8(mode, count, &type, indices, primcount);
end;
[PCUNotRestore]
glMultisampleEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SampleMaskEXT_ovr_0(value: single; invert: boolean);
external 'opengl32.dll' name 'glSampleMaskEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskEXT(value: single; invert: boolean) :=
z_SampleMaskEXT_ovr_0(value, invert);
private static procedure z_SamplePatternEXT_ovr_0(pattern: OpenGL.SamplePatternEXT);
external 'opengl32.dll' name 'glSamplePatternEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplePatternEXT(pattern: OpenGL.SamplePatternEXT) :=
z_SamplePatternEXT_ovr_0(pattern);
end;
[PCUNotRestore]
glPalettedTextureEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ColorTableEXT_ovr_0(target: ColorTableTarget; _internalFormat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr);
external 'opengl32.dll' name 'glColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableEXT(target: ColorTableTarget; _internalFormat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr) :=
z_ColorTableEXT_ovr_0(target, _internalFormat, width, format, &type, table);
private static procedure z_GetColorTableEXT_ovr_0(target: ColorTableTarget; format: PixelFormat; &type: PixelType; data: IntPtr);
external 'opengl32.dll' name 'glGetColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableEXT(target: ColorTableTarget; format: PixelFormat; &type: PixelType; data: IntPtr) :=
z_GetColorTableEXT_ovr_0(target, format, &type, data);
private static procedure z_GetColorTableParameterivEXT_ovr_0(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetColorTableParameterivEXT';
private static procedure z_GetColorTableParameterivEXT_ovr_0_anh0001(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32) :=
z_GetColorTableParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameterivEXT_ovr_2(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetColorTableParameterfvEXT_ovr_0(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single);
external 'opengl32.dll' name 'glGetColorTableParameterfvEXT';
private static procedure z_GetColorTableParameterfvEXT_ovr_0_anh0001(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single) :=
z_GetColorTableParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameterfvEXT_ovr_2(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glPixelTransformEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PixelTransformParameteriEXT_ovr_0(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: Int32);
external 'opengl32.dll' name 'glPixelTransformParameteriEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameteriEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: Int32) :=
z_PixelTransformParameteriEXT_ovr_0(target, pname, param);
private static procedure z_PixelTransformParameterfEXT_ovr_0(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: single);
external 'opengl32.dll' name 'glPixelTransformParameterfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: single) :=
z_PixelTransformParameterfEXT_ovr_0(target, pname, param);
private static procedure z_PixelTransformParameterivEXT_ovr_0(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: Int32);
external 'opengl32.dll' name 'glPixelTransformParameterivEXT';
private static procedure z_PixelTransformParameterivEXT_ovr_0_anh0001(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTransformParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PixelTransformParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_PixelTransformParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: Int32) :=
z_PixelTransformParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_PixelTransformParameterivEXT_ovr_2(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTransformParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr) :=
z_PixelTransformParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_PixelTransformParameterfvEXT_ovr_0(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: single);
external 'opengl32.dll' name 'glPixelTransformParameterfvEXT';
private static procedure z_PixelTransformParameterfvEXT_ovr_0_anh0001(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTransformParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_PixelTransformParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: single) :=
z_PixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_PixelTransformParameterfvEXT_ovr_2(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTransformParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr) :=
z_PixelTransformParameterfvEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetPixelTransformParameterivEXT_ovr_0(target: DummyEnum; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetPixelTransformParameterivEXT';
private static procedure z_GetPixelTransformParameterivEXT_ovr_0_anh0001(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTransformParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPixelTransformParameterivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetPixelTransformParameterivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; var ¶ms: Int32) :=
z_GetPixelTransformParameterivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetPixelTransformParameterivEXT_ovr_2(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTransformParameterivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetPixelTransformParameterivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetPixelTransformParameterfvEXT_ovr_0(target: DummyEnum; pname: DummyEnum; var ¶ms: single);
external 'opengl32.dll' name 'glGetPixelTransformParameterfvEXT';
private static procedure z_GetPixelTransformParameterfvEXT_ovr_0_anh0001(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTransformParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetPixelTransformParameterfvEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; var ¶ms: single) :=
z_GetPixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetPixelTransformParameterfvEXT_ovr_2(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTransformParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetPixelTransformParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glPointParametersEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PointParameterfEXT_ovr_0(pname: PointParameterNameARB; param: single);
external 'opengl32.dll' name 'glPointParameterfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfEXT(pname: PointParameterNameARB; param: single) :=
z_PointParameterfEXT_ovr_0(pname, param);
private static procedure z_PointParameterfvEXT_ovr_0(pname: PointParameterNameARB; var ¶ms: single);
external 'opengl32.dll' name 'glPointParameterfvEXT';
private static procedure z_PointParameterfvEXT_ovr_0_anh001(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterfvEXT_ovr_0(pname, ¶ms[0]) else
z_PointParameterfvEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; var ¶ms: single) :=
z_PointParameterfvEXT_ovr_0(pname, ¶ms);
private static procedure z_PointParameterfvEXT_ovr_2(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterfvEXT_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glPolygonOffsetEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PolygonOffsetEXT_ovr_0(factor: single; bias: single);
external 'opengl32.dll' name 'glPolygonOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetEXT(factor: single; bias: single) :=
z_PolygonOffsetEXT_ovr_0(factor, bias);
end;
[PCUNotRestore]
glPolygonOffsetClampEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PolygonOffsetClampEXT_ovr_0(factor: single; units: single; clamp: single);
external 'opengl32.dll' name 'glPolygonOffsetClampEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetClampEXT(factor: single; units: single; clamp: single) :=
z_PolygonOffsetClampEXT_ovr_0(factor, units, clamp);
end;
[PCUNotRestore]
glProvokingVertexEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProvokingVertexEXT_ovr_0(mode: VertexProvokingMode);
external 'opengl32.dll' name 'glProvokingVertexEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProvokingVertexEXT(mode: VertexProvokingMode) :=
z_ProvokingVertexEXT_ovr_0(mode);
end;
[PCUNotRestore]
glRasterMultisampleEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RasterSamplesEXT_ovr_0(samples: UInt32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glRasterSamplesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterSamplesEXT(samples: UInt32; fixedsamplelocations: boolean) :=
z_RasterSamplesEXT_ovr_0(samples, fixedsamplelocations);
end;
[PCUNotRestore]
glSemaphoreEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetUnsignedBytevEXT_ovr_0(pname: GetPName; var data: Byte);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
private static procedure z_GetUnsignedBytevEXT_ovr_0_anh001(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: array of Byte) :=
if (data<>nil) and (data.Length<>0) then
z_GetUnsignedBytevEXT_ovr_0(pname, data[0]) else
z_GetUnsignedBytevEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; var data: Byte) :=
z_GetUnsignedBytevEXT_ovr_0(pname, data);
private static procedure z_GetUnsignedBytevEXT_ovr_2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytevEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: IntPtr) :=
z_GetUnsignedBytevEXT_ovr_2(pname, data);
private static procedure z_GetUnsignedBytei_vEXT_ovr_0(target: DummyEnum; index: UInt32; var data: Byte);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
private static procedure z_GetUnsignedBytei_vEXT_ovr_0_anh0001(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: array of Byte) :=
if (data<>nil) and (data.Length<>0) then
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data[0]) else
z_GetUnsignedBytei_vEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; var data: Byte) :=
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data);
private static procedure z_GetUnsignedBytei_vEXT_ovr_2(target: DummyEnum; index: UInt32; data: IntPtr);
external 'opengl32.dll' name 'glGetUnsignedBytei_vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: IntPtr) :=
z_GetUnsignedBytei_vEXT_ovr_2(target, index, data);
private static procedure z_GenSemaphoresEXT_ovr_0(n: Int32; var semaphores: UInt32);
external 'opengl32.dll' name 'glGenSemaphoresEXT';
private static procedure z_GenSemaphoresEXT_ovr_0_anh001(n: Int32; semaphores: IntPtr);
external 'opengl32.dll' name 'glGenSemaphoresEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; semaphores: array of UInt32) :=
if (semaphores<>nil) and (semaphores.Length<>0) then
z_GenSemaphoresEXT_ovr_0(n, semaphores[0]) else
z_GenSemaphoresEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; var semaphores: UInt32) :=
z_GenSemaphoresEXT_ovr_0(n, semaphores);
private static procedure z_GenSemaphoresEXT_ovr_2(n: Int32; semaphores: IntPtr);
external 'opengl32.dll' name 'glGenSemaphoresEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; semaphores: IntPtr) :=
z_GenSemaphoresEXT_ovr_2(n, semaphores);
private static procedure z_DeleteSemaphoresEXT_ovr_0(n: Int32; var semaphores: UInt32);
external 'opengl32.dll' name 'glDeleteSemaphoresEXT';
private static procedure z_DeleteSemaphoresEXT_ovr_0_anh001(n: Int32; semaphores: IntPtr);
external 'opengl32.dll' name 'glDeleteSemaphoresEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; semaphores: array of UInt32) :=
if (semaphores<>nil) and (semaphores.Length<>0) then
z_DeleteSemaphoresEXT_ovr_0(n, semaphores[0]) else
z_DeleteSemaphoresEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; var semaphores: UInt32) :=
z_DeleteSemaphoresEXT_ovr_0(n, semaphores);
private static procedure z_DeleteSemaphoresEXT_ovr_2(n: Int32; semaphores: IntPtr);
external 'opengl32.dll' name 'glDeleteSemaphoresEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; semaphores: IntPtr) :=
z_DeleteSemaphoresEXT_ovr_2(n, semaphores);
private static function z_IsSemaphoreEXT_ovr_0(semaphore: UInt32): boolean;
external 'opengl32.dll' name 'glIsSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSemaphoreEXT(semaphore: UInt32): boolean :=
z_IsSemaphoreEXT_ovr_0(semaphore);
private static procedure z_SemaphoreParameterui64vEXT_ovr_0(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64);
external 'opengl32.dll' name 'glSemaphoreParameterui64vEXT';
private static procedure z_SemaphoreParameterui64vEXT_ovr_0_anh0001(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSemaphoreParameterui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_SemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms[0]) else
z_SemaphoreParameterui64vEXT_ovr_0_anh0001(semaphore, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64) :=
z_SemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms);
private static procedure z_SemaphoreParameterui64vEXT_ovr_2(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSemaphoreParameterui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr) :=
z_SemaphoreParameterui64vEXT_ovr_2(semaphore, pname, ¶ms);
private static procedure z_GetSemaphoreParameterui64vEXT_ovr_0(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetSemaphoreParameterui64vEXT';
private static procedure z_GetSemaphoreParameterui64vEXT_ovr_0_anh0001(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSemaphoreParameterui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetSemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms[0]) else
z_GetSemaphoreParameterui64vEXT_ovr_0_anh0001(semaphore, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64) :=
z_GetSemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms);
private static procedure z_GetSemaphoreParameterui64vEXT_ovr_2(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetSemaphoreParameterui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr) :=
z_GetSemaphoreParameterui64vEXT_ovr_2(semaphore, pname, ¶ms);
private static procedure z_WaitSemaphoreEXT_ovr_0(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0000011(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_0_anh0001011(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000011(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, IntPtr.Zero) else
if (textures<>nil) and (textures.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0001011(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_WaitSemaphoreEXT_ovr_1_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_1_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_1_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, srcLayouts) else
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_0_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_2(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_2_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_2_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_2_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_2_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, srcLayouts) else
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_2_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_2_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_3_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_3_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, IntPtr.Zero);
private static procedure z_WaitSemaphoreEXT_ovr_4_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts) else
z_WaitSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_5_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts) else
z_WaitSemaphoreEXT_ovr_2_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_6(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_6_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_6_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_6_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_6_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_6_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_6_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, IntPtr.Zero);
private static procedure z_WaitSemaphoreEXT_ovr_7_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts) else
z_WaitSemaphoreEXT_ovr_6_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_8(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_8_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_WaitSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts) else
z_WaitSemaphoreEXT_ovr_8_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000011(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_2_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout) :=
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout) :=
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr) :=
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout) :=
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_6_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout) :=
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr) :=
z_WaitSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_18(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_18_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_18_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_18_anh0000011(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_18_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], IntPtr.Zero) else
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_18_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_18_anh0000011(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_WaitSemaphoreEXT_ovr_19_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_18_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_20(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_20_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_WaitSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts) else
z_WaitSemaphoreEXT_ovr_20_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout) :=
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_18_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout) :=
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr) :=
z_WaitSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_24(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
private static procedure z_WaitSemaphoreEXT_ovr_24_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout) :=
if (srcLayouts<>nil) and (srcLayouts.Length<>0) then
z_WaitSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]) else
z_WaitSemaphoreEXT_ovr_24_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout) :=
z_WaitSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
private static procedure z_WaitSemaphoreEXT_ovr_26(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr) :=
z_WaitSemaphoreEXT_ovr_26(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_0(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0000011(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_0_anh0001011(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000011(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, IntPtr.Zero) else
if (textures<>nil) and (textures.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0001011(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_SignalSemaphoreEXT_ovr_1_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_1_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_1_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, dstLayouts) else
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_0_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_2(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_2_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_2_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_2_anh0001010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_2_anh0000010(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, IntPtr.Zero, dstLayouts) else
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_2_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_2_anh0001010(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, IntPtr.Zero, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_3_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_3_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, IntPtr.Zero);
private static procedure z_SignalSemaphoreEXT_ovr_4_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts) else
z_SignalSemaphoreEXT_ovr_0_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_5_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts) else
z_SignalSemaphoreEXT_ovr_2_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_6(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_6_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_6_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_6_anh0001001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_6_anh0000001(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_6_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_6_anh0001001(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, IntPtr.Zero);
private static procedure z_SignalSemaphoreEXT_ovr_7_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts) else
z_SignalSemaphoreEXT_ovr_6_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_8(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_8_anh0001000(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr) :=
if (buffers<>nil) and (buffers.Length<>0) then
z_SignalSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts) else
z_SignalSemaphoreEXT_ovr_8_anh0001000(semaphore, numBufferBarriers, IntPtr.Zero, numTextureBarriers, textures, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000011(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_0_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_2_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout) :=
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_0_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout) :=
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr) :=
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout) :=
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_6_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout) :=
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr) :=
z_SignalSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_18(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_18_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_18_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_18_anh0000011(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_18_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], IntPtr.Zero) else
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_18_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_18_anh0000011(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, IntPtr.Zero);
private static procedure z_SignalSemaphoreEXT_ovr_19_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout) :=
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_18_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_20(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_20_anh0000010(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_SignalSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts) else
z_SignalSemaphoreEXT_ovr_20_anh0000010(semaphore, numBufferBarriers, buffers, numTextureBarriers, IntPtr.Zero, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout) :=
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_18_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout) :=
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr) :=
z_SignalSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_24(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
private static procedure z_SignalSemaphoreEXT_ovr_24_anh0000001(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout) :=
if (dstLayouts<>nil) and (dstLayouts.Length<>0) then
z_SignalSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]) else
z_SignalSemaphoreEXT_ovr_24_anh0000001(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout) :=
z_SignalSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
private static procedure z_SignalSemaphoreEXT_ovr_26(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr) :=
z_SignalSemaphoreEXT_ovr_26(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
[PCUNotRestore]
glSemaphoreFdEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ImportSemaphoreFdEXT_ovr_0(semaphore: UInt32; handleType: ExternalHandleType; fd: Int32);
external 'opengl32.dll' name 'glImportSemaphoreFdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreFdEXT(semaphore: UInt32; handleType: ExternalHandleType; fd: Int32) :=
z_ImportSemaphoreFdEXT_ovr_0(semaphore, handleType, fd);
end;
[PCUNotRestore]
glSemaphoreWin32EXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ImportSemaphoreWin32HandleEXT_ovr_0(semaphore: UInt32; handleType: ExternalHandleType; handle: IntPtr);
external 'opengl32.dll' name 'glImportSemaphoreWin32HandleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreWin32HandleEXT(semaphore: UInt32; handleType: ExternalHandleType; handle: IntPtr) :=
z_ImportSemaphoreWin32HandleEXT_ovr_0(semaphore, handleType, handle);
private static procedure z_ImportSemaphoreWin32NameEXT_ovr_0(semaphore: UInt32; handleType: ExternalHandleType; name: IntPtr);
external 'opengl32.dll' name 'glImportSemaphoreWin32NameEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreWin32NameEXT(semaphore: UInt32; handleType: ExternalHandleType; name: IntPtr) :=
z_ImportSemaphoreWin32NameEXT_ovr_0(semaphore, handleType, name);
end;
[PCUNotRestore]
glSecondaryColorEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SecondaryColor3bEXT_ovr_0(red: SByte; green: SByte; blue: SByte);
external 'opengl32.dll' name 'glSecondaryColor3bEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bEXT(red: SByte; green: SByte; blue: SByte) :=
z_SecondaryColor3bEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3bvEXT_ovr_0(var v: SByte);
external 'opengl32.dll' name 'glSecondaryColor3bvEXT';
private static procedure z_SecondaryColor3bvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3bvEXT_ovr_0(v[0]) else
z_SecondaryColor3bvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(var v: SByte) :=
z_SecondaryColor3bvEXT_ovr_0(v);
private static procedure z_SecondaryColor3bvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(v: IntPtr) :=
z_SecondaryColor3bvEXT_ovr_2(v);
private static procedure z_SecondaryColor3dEXT_ovr_0(red: real; green: real; blue: real);
external 'opengl32.dll' name 'glSecondaryColor3dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dEXT(red: real; green: real; blue: real) :=
z_SecondaryColor3dEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3dvEXT_ovr_0(var v: real);
external 'opengl32.dll' name 'glSecondaryColor3dvEXT';
private static procedure z_SecondaryColor3dvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3dvEXT_ovr_0(v[0]) else
z_SecondaryColor3dvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(var v: real) :=
z_SecondaryColor3dvEXT_ovr_0(v);
private static procedure z_SecondaryColor3dvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(v: IntPtr) :=
z_SecondaryColor3dvEXT_ovr_2(v);
private static procedure z_SecondaryColor3fEXT_ovr_0(red: single; green: single; blue: single);
external 'opengl32.dll' name 'glSecondaryColor3fEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fEXT(red: single; green: single; blue: single) :=
z_SecondaryColor3fEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3fvEXT_ovr_0(var v: single);
external 'opengl32.dll' name 'glSecondaryColor3fvEXT';
private static procedure z_SecondaryColor3fvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3fvEXT_ovr_0(v[0]) else
z_SecondaryColor3fvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(var v: single) :=
z_SecondaryColor3fvEXT_ovr_0(v);
private static procedure z_SecondaryColor3fvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3fvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(v: IntPtr) :=
z_SecondaryColor3fvEXT_ovr_2(v);
private static procedure z_SecondaryColor3iEXT_ovr_0(red: Int32; green: Int32; blue: Int32);
external 'opengl32.dll' name 'glSecondaryColor3iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iEXT(red: Int32; green: Int32; blue: Int32) :=
z_SecondaryColor3iEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3ivEXT_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glSecondaryColor3ivEXT';
private static procedure z_SecondaryColor3ivEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3ivEXT_ovr_0(v[0]) else
z_SecondaryColor3ivEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(var v: Int32) :=
z_SecondaryColor3ivEXT_ovr_0(v);
private static procedure z_SecondaryColor3ivEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(v: IntPtr) :=
z_SecondaryColor3ivEXT_ovr_2(v);
private static procedure z_SecondaryColor3sEXT_ovr_0(red: Int16; green: Int16; blue: Int16);
external 'opengl32.dll' name 'glSecondaryColor3sEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sEXT(red: Int16; green: Int16; blue: Int16) :=
z_SecondaryColor3sEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3svEXT_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glSecondaryColor3svEXT';
private static procedure z_SecondaryColor3svEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3svEXT_ovr_0(v[0]) else
z_SecondaryColor3svEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(var v: Int16) :=
z_SecondaryColor3svEXT_ovr_0(v);
private static procedure z_SecondaryColor3svEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(v: IntPtr) :=
z_SecondaryColor3svEXT_ovr_2(v);
private static procedure z_SecondaryColor3ubEXT_ovr_0(red: Byte; green: Byte; blue: Byte);
external 'opengl32.dll' name 'glSecondaryColor3ubEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubEXT(red: Byte; green: Byte; blue: Byte) :=
z_SecondaryColor3ubEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3ubvEXT_ovr_0(var v: Byte);
external 'opengl32.dll' name 'glSecondaryColor3ubvEXT';
private static procedure z_SecondaryColor3ubvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3ubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3ubvEXT_ovr_0(v[0]) else
z_SecondaryColor3ubvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(var v: Byte) :=
z_SecondaryColor3ubvEXT_ovr_0(v);
private static procedure z_SecondaryColor3ubvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3ubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(v: IntPtr) :=
z_SecondaryColor3ubvEXT_ovr_2(v);
private static procedure z_SecondaryColor3uiEXT_ovr_0(red: UInt32; green: UInt32; blue: UInt32);
external 'opengl32.dll' name 'glSecondaryColor3uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiEXT(red: UInt32; green: UInt32; blue: UInt32) :=
z_SecondaryColor3uiEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3uivEXT_ovr_0(var v: UInt32);
external 'opengl32.dll' name 'glSecondaryColor3uivEXT';
private static procedure z_SecondaryColor3uivEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3uivEXT_ovr_0(v[0]) else
z_SecondaryColor3uivEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(var v: UInt32) :=
z_SecondaryColor3uivEXT_ovr_0(v);
private static procedure z_SecondaryColor3uivEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(v: IntPtr) :=
z_SecondaryColor3uivEXT_ovr_2(v);
private static procedure z_SecondaryColor3usEXT_ovr_0(red: UInt16; green: UInt16; blue: UInt16);
external 'opengl32.dll' name 'glSecondaryColor3usEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usEXT(red: UInt16; green: UInt16; blue: UInt16) :=
z_SecondaryColor3usEXT_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3usvEXT_ovr_0(var v: UInt16);
external 'opengl32.dll' name 'glSecondaryColor3usvEXT';
private static procedure z_SecondaryColor3usvEXT_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3usvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3usvEXT_ovr_0(v[0]) else
z_SecondaryColor3usvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(var v: UInt16) :=
z_SecondaryColor3usvEXT_ovr_0(v);
private static procedure z_SecondaryColor3usvEXT_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3usvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(v: IntPtr) :=
z_SecondaryColor3usvEXT_ovr_2(v);
private static procedure z_SecondaryColorPointerEXT_ovr_0(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glSecondaryColorPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerEXT(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr) :=
z_SecondaryColorPointerEXT_ovr_0(size, &type, stride, pointer);
end;
[PCUNotRestore]
glSeparateShaderObjectsEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_UseShaderProgramEXT_ovr_0(&type: DummyEnum; &program: UInt32);
external 'opengl32.dll' name 'glUseShaderProgramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseShaderProgramEXT(&type: DummyEnum; &program: UInt32) :=
z_UseShaderProgramEXT_ovr_0(&type, &program);
private static procedure z_ActiveProgramEXT_ovr_0(&program: UInt32);
external 'opengl32.dll' name 'glActiveProgramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveProgramEXT(&program: UInt32) :=
z_ActiveProgramEXT_ovr_0(&program);
private static function z_CreateShaderProgramEXT_ovr_0(&type: ShaderType; _string: IntPtr): UInt32;
external 'opengl32.dll' name 'glCreateShaderProgramEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramEXT(&type: ShaderType; _string: string): UInt32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(_string);
Result := z_CreateShaderProgramEXT_ovr_0(&type, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramEXT(&type: ShaderType; _string: IntPtr): UInt32 :=
z_CreateShaderProgramEXT_ovr_0(&type, _string);
end;
[PCUNotRestore]
glShaderFramebufferFetchNonCoherentEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferFetchBarrierEXT_ovr_0;
external 'opengl32.dll' name 'glFramebufferFetchBarrierEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferFetchBarrierEXT :=
z_FramebufferFetchBarrierEXT_ovr_0;
end;
[PCUNotRestore]
glShaderImageLoadStoreEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindImageTextureEXT_ovr_0(index: UInt32; texture: UInt32; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: Int32);
external 'opengl32.dll' name 'glBindImageTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextureEXT(index: UInt32; texture: UInt32; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: Int32) :=
z_BindImageTextureEXT_ovr_0(index, texture, level, layered, layer, access, format);
private static procedure z_MemoryBarrierEXT_ovr_0(barriers: MemoryBarrierMask);
external 'opengl32.dll' name 'glMemoryBarrierEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrierEXT(barriers: MemoryBarrierMask) :=
z_MemoryBarrierEXT_ovr_0(barriers);
end;
[PCUNotRestore]
glStencilClearTagEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_StencilClearTagEXT_ovr_0(stencilTagBits: Int32; stencilClearTag: UInt32);
external 'opengl32.dll' name 'glStencilClearTagEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilClearTagEXT(stencilTagBits: Int32; stencilClearTag: UInt32) :=
z_StencilClearTagEXT_ovr_0(stencilTagBits, stencilClearTag);
end;
[PCUNotRestore]
glStencilTwoSideEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ActiveStencilFaceEXT_ovr_0(face: StencilFaceDirection);
external 'opengl32.dll' name 'glActiveStencilFaceEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveStencilFaceEXT(face: StencilFaceDirection) :=
z_ActiveStencilFaceEXT_ovr_0(face);
end;
[PCUNotRestore]
glSubtextureEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexSubImage1DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage1DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage1DEXT(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage1DEXT_ovr_0(target, level, xoffset, width, format, &type, pixels);
private static procedure z_TexSubImage2DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage2DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage2DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage2DEXT_ovr_0(target, level, xoffset, yoffset, width, height, format, &type, pixels);
end;
[PCUNotRestore]
glTexture3DEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexImage3DEXT_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3DEXT(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexImage3DEXT_ovr_0(target, level, _internalformat, width, height, depth, border, format, &type, pixels);
private static procedure z_TexSubImage3DEXT_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage3DEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage3DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage3DEXT_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
[PCUNotRestore]
glTextureArrayEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferTextureLayerEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glFramebufferTextureLayerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayerEXT(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32) :=
z_FramebufferTextureLayerEXT_ovr_0(target, attachment, texture, level, layer);
end;
[PCUNotRestore]
glTextureBufferObjectEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexBufferEXT_ovr_0(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
external 'opengl32.dll' name 'glTexBufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferEXT(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32) :=
z_TexBufferEXT_ovr_0(target, _internalformat, buffer);
end;
[PCUNotRestore]
glTextureIntegerEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexParameterIivEXT_ovr_0(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexParameterIivEXT';
private static procedure z_TexParameterIivEXT_ovr_0_anh0001(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterIivEXT_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterIivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) :=
z_TexParameterIivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_TexParameterIivEXT_ovr_2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameterIivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_TexParameterIuivEXT_ovr_0(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
external 'opengl32.dll' name 'glTexParameterIuivEXT';
private static procedure z_TexParameterIuivEXT_ovr_0_anh0001(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterIuivEXT_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterIuivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32) :=
z_TexParameterIuivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_TexParameterIuivEXT_ovr_2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) :=
z_TexParameterIuivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetTexParameterIivEXT_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexParameterIivEXT';
private static procedure z_GetTexParameterIivEXT_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterIivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterIivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) :=
z_GetTexParameterIivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameterIivEXT_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterIivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_GetTexParameterIuivEXT_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetTexParameterIuivEXT';
private static procedure z_GetTexParameterIuivEXT_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterIuivEXT_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterIuivEXT_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32) :=
z_GetTexParameterIuivEXT_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameterIuivEXT_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterIuivEXT_ovr_2(target, pname, ¶ms);
private static procedure z_ClearColorIiEXT_ovr_0(red: Int32; green: Int32; blue: Int32; alpha: Int32);
external 'opengl32.dll' name 'glClearColorIiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorIiEXT(red: Int32; green: Int32; blue: Int32; alpha: Int32) :=
z_ClearColorIiEXT_ovr_0(red, green, blue, alpha);
private static procedure z_ClearColorIuiEXT_ovr_0(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32);
external 'opengl32.dll' name 'glClearColorIuiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorIuiEXT(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32) :=
z_ClearColorIuiEXT_ovr_0(red, green, blue, alpha);
end;
[PCUNotRestore]
glTextureObjectEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_AreTexturesResidentEXT_ovr_0(n: Int32; var textures: UInt32; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
private static function z_AreTexturesResidentEXT_ovr_0_anh0010(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
private static function z_AreTexturesResidentEXT_ovr_0_anh0001(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
private static function z_AreTexturesResidentEXT_ovr_0_anh0011(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; residences: array of boolean): boolean :=
if (textures<>nil) and (textures.Length<>0) then
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResidentEXT_ovr_0(n, textures[0], residences[0]) else
z_AreTexturesResidentEXT_ovr_0_anh0001(n, textures[0], IntPtr.Zero) else
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResidentEXT_ovr_0_anh0010(n, IntPtr.Zero, residences[0]) else
z_AreTexturesResidentEXT_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static function z_AreTexturesResidentEXT_ovr_1_anh0010(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; var residences: boolean): boolean :=
if (textures<>nil) and (textures.Length<>0) then
z_AreTexturesResidentEXT_ovr_0(n, textures[0], residences) else
z_AreTexturesResidentEXT_ovr_0_anh0010(n, IntPtr.Zero, residences);
private static function z_AreTexturesResidentEXT_ovr_2(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
private static function z_AreTexturesResidentEXT_ovr_2_anh0010(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; residences: IntPtr): boolean :=
if (textures<>nil) and (textures.Length<>0) then
z_AreTexturesResidentEXT_ovr_2(n, textures[0], residences) else
z_AreTexturesResidentEXT_ovr_2_anh0010(n, IntPtr.Zero, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResidentEXT_ovr_0(n, textures, residences[0]) else
z_AreTexturesResidentEXT_ovr_0_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; var residences: boolean): boolean :=
z_AreTexturesResidentEXT_ovr_0(n, textures, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; residences: IntPtr): boolean :=
z_AreTexturesResidentEXT_ovr_2(n, textures, residences);
private static function z_AreTexturesResidentEXT_ovr_6(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
private static function z_AreTexturesResidentEXT_ovr_6_anh0001(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreTexturesResidentEXT_ovr_6(n, textures, residences[0]) else
z_AreTexturesResidentEXT_ovr_6_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; var residences: boolean): boolean :=
z_AreTexturesResidentEXT_ovr_6(n, textures, residences);
private static function z_AreTexturesResidentEXT_ovr_8(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResidentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; residences: IntPtr): boolean :=
z_AreTexturesResidentEXT_ovr_8(n, textures, residences);
private static procedure z_BindTextureEXT_ovr_0(target: TextureTarget; texture: UInt32);
external 'opengl32.dll' name 'glBindTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextureEXT(target: TextureTarget; texture: UInt32) :=
z_BindTextureEXT_ovr_0(target, texture);
private static procedure z_DeleteTexturesEXT_ovr_0(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glDeleteTexturesEXT';
private static procedure z_DeleteTexturesEXT_ovr_0_anh001(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glDeleteTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_DeleteTexturesEXT_ovr_0(n, textures[0]) else
z_DeleteTexturesEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; var textures: UInt32) :=
z_DeleteTexturesEXT_ovr_0(n, textures);
private static procedure z_DeleteTexturesEXT_ovr_2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glDeleteTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; textures: IntPtr) :=
z_DeleteTexturesEXT_ovr_2(n, textures);
private static procedure z_GenTexturesEXT_ovr_0(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glGenTexturesEXT';
private static procedure z_GenTexturesEXT_ovr_0_anh001(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glGenTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; textures: array of UInt32) :=
if (textures<>nil) and (textures.Length<>0) then
z_GenTexturesEXT_ovr_0(n, textures[0]) else
z_GenTexturesEXT_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; var textures: UInt32) :=
z_GenTexturesEXT_ovr_0(n, textures);
private static procedure z_GenTexturesEXT_ovr_2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glGenTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; textures: IntPtr) :=
z_GenTexturesEXT_ovr_2(n, textures);
private static function z_IsTextureEXT_ovr_0(texture: UInt32): boolean;
external 'opengl32.dll' name 'glIsTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureEXT(texture: UInt32): boolean :=
z_IsTextureEXT_ovr_0(texture);
private static procedure z_PrioritizeTexturesEXT_ovr_0(n: Int32; var textures: UInt32; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
private static procedure z_PrioritizeTexturesEXT_ovr_0_anh0010(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
private static procedure z_PrioritizeTexturesEXT_ovr_0_anh0001(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
private static procedure z_PrioritizeTexturesEXT_ovr_0_anh0011(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; priorities: array of single) :=
if (textures<>nil) and (textures.Length<>0) then
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesEXT_ovr_0(n, textures[0], priorities[0]) else
z_PrioritizeTexturesEXT_ovr_0_anh0001(n, textures[0], IntPtr.Zero) else
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesEXT_ovr_0_anh0010(n, IntPtr.Zero, priorities[0]) else
z_PrioritizeTexturesEXT_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static procedure z_PrioritizeTexturesEXT_ovr_1_anh0010(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; var priorities: single) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTexturesEXT_ovr_0(n, textures[0], priorities) else
z_PrioritizeTexturesEXT_ovr_0_anh0010(n, IntPtr.Zero, priorities);
private static procedure z_PrioritizeTexturesEXT_ovr_2(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
private static procedure z_PrioritizeTexturesEXT_ovr_2_anh0010(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; priorities: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTexturesEXT_ovr_2(n, textures[0], priorities) else
z_PrioritizeTexturesEXT_ovr_2_anh0010(n, IntPtr.Zero, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; priorities: array of single) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesEXT_ovr_0(n, textures, priorities[0]) else
z_PrioritizeTexturesEXT_ovr_0_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; var priorities: single) :=
z_PrioritizeTexturesEXT_ovr_0(n, textures, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; priorities: IntPtr) :=
z_PrioritizeTexturesEXT_ovr_2(n, textures, priorities);
private static procedure z_PrioritizeTexturesEXT_ovr_6(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
private static procedure z_PrioritizeTexturesEXT_ovr_6_anh0001(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; priorities: array of single) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesEXT_ovr_6(n, textures, priorities[0]) else
z_PrioritizeTexturesEXT_ovr_6_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; var priorities: single) :=
z_PrioritizeTexturesEXT_ovr_6(n, textures, priorities);
private static procedure z_PrioritizeTexturesEXT_ovr_8(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; priorities: IntPtr) :=
z_PrioritizeTexturesEXT_ovr_8(n, textures, priorities);
end;
[PCUNotRestore]
glTexturePerturbNormalEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureNormalEXT_ovr_0(mode: TextureNormalModeEXT);
external 'opengl32.dll' name 'glTextureNormalEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureNormalEXT(mode: TextureNormalModeEXT) :=
z_TextureNormalEXT_ovr_0(mode);
end;
[PCUNotRestore]
glTimerQueryEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetQueryObjecti64vEXT_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetQueryObjecti64vEXT';
private static procedure z_GetQueryObjecti64vEXT_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjecti64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjecti64vEXT_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjecti64vEXT_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64) :=
z_GetQueryObjecti64vEXT_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjecti64vEXT_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjecti64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjecti64vEXT_ovr_2(id, pname, ¶ms);
private static procedure z_GetQueryObjectui64vEXT_ovr_0(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetQueryObjectui64vEXT';
private static procedure z_GetQueryObjectui64vEXT_ovr_0_anh0001(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetQueryObjectui64vEXT_ovr_0(id, pname, ¶ms[0]) else
z_GetQueryObjectui64vEXT_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64) :=
z_GetQueryObjectui64vEXT_ovr_0(id, pname, ¶ms);
private static procedure z_GetQueryObjectui64vEXT_ovr_2(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetQueryObjectui64vEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr) :=
z_GetQueryObjectui64vEXT_ovr_2(id, pname, ¶ms);
end;
[PCUNotRestore]
glTransformFeedbackEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginTransformFeedbackEXT_ovr_0(primitiveMode: PrimitiveType);
external 'opengl32.dll' name 'glBeginTransformFeedbackEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedbackEXT(primitiveMode: PrimitiveType) :=
z_BeginTransformFeedbackEXT_ovr_0(primitiveMode);
private static procedure z_EndTransformFeedbackEXT_ovr_0;
external 'opengl32.dll' name 'glEndTransformFeedbackEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedbackEXT :=
z_EndTransformFeedbackEXT_ovr_0;
private static procedure z_BindBufferRangeEXT_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glBindBufferRangeEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr) :=
z_BindBufferRangeEXT_ovr_0(target, index, buffer, offset, size);
private static procedure z_BindBufferOffsetEXT_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr);
external 'opengl32.dll' name 'glBindBufferOffsetEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr) :=
z_BindBufferOffsetEXT_ovr_0(target, index, buffer, offset);
private static procedure z_BindBufferBaseEXT_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32);
external 'opengl32.dll' name 'glBindBufferBaseEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32) :=
z_BindBufferBaseEXT_ovr_0(target, index, buffer);
private static procedure z_TransformFeedbackVaryingsEXT_ovr_0(&program: UInt32; count: Int32; var varyings: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsEXT';
private static procedure z_TransformFeedbackVaryingsEXT_ovr_0_anh00010(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsEXT(&program: UInt32; count: Int32; varyings: array of string; bufferMode: DummyEnum);
begin
var par_3_str_ptr := varyings?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
z_TransformFeedbackVaryingsEXT_ovr_0(&program, count, par_3_str_ptr[0], bufferMode) else
z_TransformFeedbackVaryingsEXT_ovr_0_anh00010(&program, count, IntPtr.Zero, bufferMode);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_TransformFeedbackVaryingsEXT_ovr_1_anh00010(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsEXT(&program: UInt32; count: Int32; varyings: array of IntPtr; bufferMode: DummyEnum) :=
if (varyings<>nil) and (varyings.Length<>0) then
z_TransformFeedbackVaryingsEXT_ovr_0(&program, count, varyings[0], bufferMode) else
z_TransformFeedbackVaryingsEXT_ovr_0_anh00010(&program, count, IntPtr.Zero, bufferMode);
private static procedure z_TransformFeedbackVaryingsEXT_ovr_2(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsEXT(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum) :=
z_TransformFeedbackVaryingsEXT_ovr_2(&program, count, varyings, bufferMode);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000110(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001110(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000010(&program, index, bufSize, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000110(&program, index, bufSize, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001110(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_1_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_1_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_1_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_2(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_2_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_2_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_2_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_2_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_2_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_3_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_3_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_4_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_5_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_6(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_6_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_6_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_6_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_6_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_6_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_7_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_8(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_8_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_8(&program, index, bufSize, length[0], size, &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_8_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_2_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_0_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_6_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_8(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_18(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000110(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_19_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: GlslTypeToken; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_20(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_20_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_20(&program, index, bufSize, length, size[0], &type, name) else
z_GetTransformFeedbackVaryingEXT_ovr_20_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_18_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_20(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_24(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_24_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetTransformFeedbackVaryingEXT_ovr_24(&program, index, bufSize, length, size, &type[0], name) else
z_GetTransformFeedbackVaryingEXT_ovr_24_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_24(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingEXT_ovr_26(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetTransformFeedbackVaryingEXT_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
[PCUNotRestore]
glVertexArrayEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ArrayElementEXT_ovr_0(i: Int32);
external 'opengl32.dll' name 'glArrayElementEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayElementEXT(i: Int32) :=
z_ArrayElementEXT_ovr_0(i);
private static procedure z_ColorPointerEXT_ovr_0(size: Int32; &type: ColorPointerType; stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glColorPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerEXT(size: Int32; &type: ColorPointerType; stride: Int32; count: Int32; pointer: IntPtr) :=
z_ColorPointerEXT_ovr_0(size, &type, stride, count, pointer);
private static procedure z_DrawArraysEXT_ovr_0(mode: PrimitiveType; first: Int32; count: Int32);
external 'opengl32.dll' name 'glDrawArraysEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysEXT(mode: PrimitiveType; first: Int32; count: Int32) :=
z_DrawArraysEXT_ovr_0(mode, first, count);
private static procedure z_EdgeFlagPointerEXT_ovr_0(stride: Int32; count: Int32; var pointer: boolean);
external 'opengl32.dll' name 'glEdgeFlagPointerEXT';
private static procedure z_EdgeFlagPointerEXT_ovr_0_anh0001(stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; pointer: array of boolean) :=
if (pointer<>nil) and (pointer.Length<>0) then
z_EdgeFlagPointerEXT_ovr_0(stride, count, pointer[0]) else
z_EdgeFlagPointerEXT_ovr_0_anh0001(stride, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; var pointer: boolean) :=
z_EdgeFlagPointerEXT_ovr_0(stride, count, pointer);
private static procedure z_EdgeFlagPointerEXT_ovr_2(stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; pointer: IntPtr) :=
z_EdgeFlagPointerEXT_ovr_2(stride, count, pointer);
private static procedure z_GetPointervEXT_ovr_0(pname: GetPointervPName; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointervEXT';
private static procedure z_GetPointervEXT_ovr_0_anh001(pname: GetPointervPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPointervEXT_ovr_0(pname, ¶ms[0]) else
z_GetPointervEXT_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; var ¶ms: IntPtr) :=
z_GetPointervEXT_ovr_0(pname, ¶ms);
private static procedure z_GetPointervEXT_ovr_2(pname: GetPointervPName; ¶ms: pointer);
external 'opengl32.dll' name 'glGetPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; ¶ms: pointer) :=
z_GetPointervEXT_ovr_2(pname, ¶ms);
private static procedure z_IndexPointerEXT_ovr_0(&type: IndexPointerType; stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glIndexPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerEXT(&type: IndexPointerType; stride: Int32; count: Int32; pointer: IntPtr) :=
z_IndexPointerEXT_ovr_0(&type, stride, count, pointer);
private static procedure z_NormalPointerEXT_ovr_0(&type: NormalPointerType; stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glNormalPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerEXT(&type: NormalPointerType; stride: Int32; count: Int32; pointer: IntPtr) :=
z_NormalPointerEXT_ovr_0(&type, stride, count, pointer);
private static procedure z_TexCoordPointerEXT_ovr_0(size: Int32; &type: TexCoordPointerType; stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glTexCoordPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerEXT(size: Int32; &type: TexCoordPointerType; stride: Int32; count: Int32; pointer: IntPtr) :=
z_TexCoordPointerEXT_ovr_0(size, &type, stride, count, pointer);
private static procedure z_VertexPointerEXT_ovr_0(size: Int32; &type: VertexPointerType; stride: Int32; count: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerEXT(size: Int32; &type: VertexPointerType; stride: Int32; count: Int32; pointer: IntPtr) :=
z_VertexPointerEXT_ovr_0(size, &type, stride, count, pointer);
end;
[PCUNotRestore]
glVertexAttrib64bitEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribL1dEXT_ovr_0(index: UInt32; x: real);
external 'opengl32.dll' name 'glVertexAttribL1dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dEXT(index: UInt32; x: real) :=
z_VertexAttribL1dEXT_ovr_0(index, x);
private static procedure z_VertexAttribL2dEXT_ovr_0(index: UInt32; x: real; y: real);
external 'opengl32.dll' name 'glVertexAttribL2dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dEXT(index: UInt32; x: real; y: real) :=
z_VertexAttribL2dEXT_ovr_0(index, x, y);
private static procedure z_VertexAttribL3dEXT_ovr_0(index: UInt32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexAttribL3dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dEXT(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttribL3dEXT_ovr_0(index, x, y, z);
private static procedure z_VertexAttribL4dEXT_ovr_0(index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexAttribL4dEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dEXT(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttribL4dEXT_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribL1dvEXT_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL1dvEXT';
private static procedure z_VertexAttribL1dvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1dvEXT_ovr_0(index, v[0]) else
z_VertexAttribL1dvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; var v: real) :=
z_VertexAttribL1dvEXT_ovr_0(index, v);
private static procedure z_VertexAttribL1dvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribL1dvEXT_ovr_2(index, v);
private static procedure z_VertexAttribL2dvEXT_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL2dvEXT';
private static procedure z_VertexAttribL2dvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL2dvEXT_ovr_0(index, v[0]) else
z_VertexAttribL2dvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; var v: real) :=
z_VertexAttribL2dvEXT_ovr_0(index, v);
private static procedure z_VertexAttribL2dvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribL2dvEXT_ovr_2(index, v);
private static procedure z_VertexAttribL3dvEXT_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL3dvEXT';
private static procedure z_VertexAttribL3dvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL3dvEXT_ovr_0(index, v[0]) else
z_VertexAttribL3dvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; var v: real) :=
z_VertexAttribL3dvEXT_ovr_0(index, v);
private static procedure z_VertexAttribL3dvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribL3dvEXT_ovr_2(index, v);
private static procedure z_VertexAttribL4dvEXT_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttribL4dvEXT';
private static procedure z_VertexAttribL4dvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL4dvEXT_ovr_0(index, v[0]) else
z_VertexAttribL4dvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; var v: real) :=
z_VertexAttribL4dvEXT_ovr_0(index, v);
private static procedure z_VertexAttribL4dvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4dvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribL4dvEXT_ovr_2(index, v);
private static procedure z_VertexAttribLPointerEXT_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribLPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLPointerEXT(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexAttribLPointerEXT_ovr_0(index, size, &type, stride, pointer);
private static procedure z_GetVertexAttribLdvEXT_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: real);
external 'opengl32.dll' name 'glGetVertexAttribLdvEXT';
private static procedure z_GetVertexAttribLdvEXT_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLdvEXT_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLdvEXT_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; var ¶ms: real) :=
z_GetVertexAttribLdvEXT_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribLdvEXT_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLdvEXT_ovr_2(index, pname, ¶ms);
end;
[PCUNotRestore]
glVertexShaderEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginVertexShaderEXT_ovr_0;
external 'opengl32.dll' name 'glBeginVertexShaderEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginVertexShaderEXT :=
z_BeginVertexShaderEXT_ovr_0;
private static procedure z_EndVertexShaderEXT_ovr_0;
external 'opengl32.dll' name 'glEndVertexShaderEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndVertexShaderEXT :=
z_EndVertexShaderEXT_ovr_0;
private static procedure z_BindVertexShaderEXT_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glBindVertexShaderEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexShaderEXT(id: UInt32) :=
z_BindVertexShaderEXT_ovr_0(id);
private static function z_GenVertexShadersEXT_ovr_0(range: UInt32): UInt32;
external 'opengl32.dll' name 'glGenVertexShadersEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenVertexShadersEXT(range: UInt32): UInt32 :=
z_GenVertexShadersEXT_ovr_0(range);
private static procedure z_DeleteVertexShaderEXT_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glDeleteVertexShaderEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexShaderEXT(id: UInt32) :=
z_DeleteVertexShaderEXT_ovr_0(id);
private static procedure z_ShaderOp1EXT_ovr_0(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32);
external 'opengl32.dll' name 'glShaderOp1EXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp1EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32) :=
z_ShaderOp1EXT_ovr_0(op, res, arg1);
private static procedure z_ShaderOp2EXT_ovr_0(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32);
external 'opengl32.dll' name 'glShaderOp2EXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp2EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32) :=
z_ShaderOp2EXT_ovr_0(op, res, arg1, arg2);
private static procedure z_ShaderOp3EXT_ovr_0(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32; arg3: UInt32);
external 'opengl32.dll' name 'glShaderOp3EXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp3EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32; arg3: UInt32) :=
z_ShaderOp3EXT_ovr_0(op, res, arg1, arg2, arg3);
private static procedure z_SwizzleEXT_ovr_0(res: UInt32; &in: UInt32; outX: VertexShaderCoordOutEXT; outY: VertexShaderCoordOutEXT; outZ: VertexShaderCoordOutEXT; outW: VertexShaderCoordOutEXT);
external 'opengl32.dll' name 'glSwizzleEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SwizzleEXT(res: UInt32; &in: UInt32; outX: VertexShaderCoordOutEXT; outY: VertexShaderCoordOutEXT; outZ: VertexShaderCoordOutEXT; outW: VertexShaderCoordOutEXT) :=
z_SwizzleEXT_ovr_0(res, &in, outX, outY, outZ, outW);
private static procedure z_WriteMaskEXT_ovr_0(res: UInt32; &in: UInt32; outX: VertexShaderWriteMaskEXT; outY: VertexShaderWriteMaskEXT; outZ: VertexShaderWriteMaskEXT; outW: VertexShaderWriteMaskEXT);
external 'opengl32.dll' name 'glWriteMaskEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WriteMaskEXT(res: UInt32; &in: UInt32; outX: VertexShaderWriteMaskEXT; outY: VertexShaderWriteMaskEXT; outZ: VertexShaderWriteMaskEXT; outW: VertexShaderWriteMaskEXT) :=
z_WriteMaskEXT_ovr_0(res, &in, outX, outY, outZ, outW);
private static procedure z_InsertComponentEXT_ovr_0(res: UInt32; src: UInt32; num: UInt32);
external 'opengl32.dll' name 'glInsertComponentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InsertComponentEXT(res: UInt32; src: UInt32; num: UInt32) :=
z_InsertComponentEXT_ovr_0(res, src, num);
private static procedure z_ExtractComponentEXT_ovr_0(res: UInt32; src: UInt32; num: UInt32);
external 'opengl32.dll' name 'glExtractComponentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExtractComponentEXT(res: UInt32; src: UInt32; num: UInt32) :=
z_ExtractComponentEXT_ovr_0(res, src, num);
private static function z_GenSymbolsEXT_ovr_0(datatype: DataTypeEXT; storagetype: VertexShaderStorageTypeEXT; range: ParameterRangeEXT; components: UInt32): UInt32;
external 'opengl32.dll' name 'glGenSymbolsEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenSymbolsEXT(datatype: DataTypeEXT; storagetype: VertexShaderStorageTypeEXT; range: ParameterRangeEXT; components: UInt32): UInt32 :=
z_GenSymbolsEXT_ovr_0(datatype, storagetype, range, components);
private static procedure z_SetInvariantEXT_ovr_0(id: UInt32; &type: ScalarType; addr: IntPtr);
external 'opengl32.dll' name 'glSetInvariantEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetInvariantEXT(id: UInt32; &type: ScalarType; addr: IntPtr) :=
z_SetInvariantEXT_ovr_0(id, &type, addr);
private static procedure z_SetLocalConstantEXT_ovr_0(id: UInt32; &type: ScalarType; addr: IntPtr);
external 'opengl32.dll' name 'glSetLocalConstantEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetLocalConstantEXT(id: UInt32; &type: ScalarType; addr: IntPtr) :=
z_SetLocalConstantEXT_ovr_0(id, &type, addr);
private static procedure z_VariantbvEXT_ovr_0(id: UInt32; var addr: SByte);
external 'opengl32.dll' name 'glVariantbvEXT';
private static procedure z_VariantbvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantbvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; addr: array of SByte) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantbvEXT_ovr_0(id, addr[0]) else
z_VariantbvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; var addr: SByte) :=
z_VariantbvEXT_ovr_0(id, addr);
private static procedure z_VariantbvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantbvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; addr: IntPtr) :=
z_VariantbvEXT_ovr_2(id, addr);
private static procedure z_VariantsvEXT_ovr_0(id: UInt32; var addr: Int16);
external 'opengl32.dll' name 'glVariantsvEXT';
private static procedure z_VariantsvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantsvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; addr: array of Int16) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantsvEXT_ovr_0(id, addr[0]) else
z_VariantsvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; var addr: Int16) :=
z_VariantsvEXT_ovr_0(id, addr);
private static procedure z_VariantsvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantsvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; addr: IntPtr) :=
z_VariantsvEXT_ovr_2(id, addr);
private static procedure z_VariantivEXT_ovr_0(id: UInt32; var addr: Int32);
external 'opengl32.dll' name 'glVariantivEXT';
private static procedure z_VariantivEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; addr: array of Int32) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantivEXT_ovr_0(id, addr[0]) else
z_VariantivEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; var addr: Int32) :=
z_VariantivEXT_ovr_0(id, addr);
private static procedure z_VariantivEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; addr: IntPtr) :=
z_VariantivEXT_ovr_2(id, addr);
private static procedure z_VariantfvEXT_ovr_0(id: UInt32; var addr: single);
external 'opengl32.dll' name 'glVariantfvEXT';
private static procedure z_VariantfvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; addr: array of single) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantfvEXT_ovr_0(id, addr[0]) else
z_VariantfvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; var addr: single) :=
z_VariantfvEXT_ovr_0(id, addr);
private static procedure z_VariantfvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; addr: IntPtr) :=
z_VariantfvEXT_ovr_2(id, addr);
private static procedure z_VariantdvEXT_ovr_0(id: UInt32; var addr: real);
external 'opengl32.dll' name 'glVariantdvEXT';
private static procedure z_VariantdvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; addr: array of real) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantdvEXT_ovr_0(id, addr[0]) else
z_VariantdvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; var addr: real) :=
z_VariantdvEXT_ovr_0(id, addr);
private static procedure z_VariantdvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantdvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; addr: IntPtr) :=
z_VariantdvEXT_ovr_2(id, addr);
private static procedure z_VariantubvEXT_ovr_0(id: UInt32; var addr: Byte);
external 'opengl32.dll' name 'glVariantubvEXT';
private static procedure z_VariantubvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; addr: array of Byte) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantubvEXT_ovr_0(id, addr[0]) else
z_VariantubvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; var addr: Byte) :=
z_VariantubvEXT_ovr_0(id, addr);
private static procedure z_VariantubvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; addr: IntPtr) :=
z_VariantubvEXT_ovr_2(id, addr);
private static procedure z_VariantusvEXT_ovr_0(id: UInt32; var addr: UInt16);
external 'opengl32.dll' name 'glVariantusvEXT';
private static procedure z_VariantusvEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantusvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; addr: array of UInt16) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantusvEXT_ovr_0(id, addr[0]) else
z_VariantusvEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; var addr: UInt16) :=
z_VariantusvEXT_ovr_0(id, addr);
private static procedure z_VariantusvEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantusvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; addr: IntPtr) :=
z_VariantusvEXT_ovr_2(id, addr);
private static procedure z_VariantuivEXT_ovr_0(id: UInt32; var addr: UInt32);
external 'opengl32.dll' name 'glVariantuivEXT';
private static procedure z_VariantuivEXT_ovr_0_anh001(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; addr: array of UInt32) :=
if (addr<>nil) and (addr.Length<>0) then
z_VariantuivEXT_ovr_0(id, addr[0]) else
z_VariantuivEXT_ovr_0_anh001(id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; var addr: UInt32) :=
z_VariantuivEXT_ovr_0(id, addr);
private static procedure z_VariantuivEXT_ovr_2(id: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; addr: IntPtr) :=
z_VariantuivEXT_ovr_2(id, addr);
private static procedure z_VariantPointerEXT_ovr_0(id: UInt32; &type: ScalarType; stride: UInt32; addr: IntPtr);
external 'opengl32.dll' name 'glVariantPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantPointerEXT(id: UInt32; &type: ScalarType; stride: UInt32; addr: IntPtr) :=
z_VariantPointerEXT_ovr_0(id, &type, stride, addr);
private static procedure z_EnableVariantClientStateEXT_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glEnableVariantClientStateEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVariantClientStateEXT(id: UInt32) :=
z_EnableVariantClientStateEXT_ovr_0(id);
private static procedure z_DisableVariantClientStateEXT_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glDisableVariantClientStateEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVariantClientStateEXT(id: UInt32) :=
z_DisableVariantClientStateEXT_ovr_0(id);
private static function z_BindLightParameterEXT_ovr_0(light: LightName; value: LightParameter): UInt32;
external 'opengl32.dll' name 'glBindLightParameterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindLightParameterEXT(light: LightName; value: LightParameter): UInt32 :=
z_BindLightParameterEXT_ovr_0(light, value);
private static function z_BindMaterialParameterEXT_ovr_0(face: MaterialFace; value: MaterialParameter): UInt32;
external 'opengl32.dll' name 'glBindMaterialParameterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindMaterialParameterEXT(face: MaterialFace; value: MaterialParameter): UInt32 :=
z_BindMaterialParameterEXT_ovr_0(face, value);
private static function z_BindTexGenParameterEXT_ovr_0(&unit: TextureUnit; coord: TextureCoordName; value: TextureGenParameter): UInt32;
external 'opengl32.dll' name 'glBindTexGenParameterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindTexGenParameterEXT(&unit: TextureUnit; coord: TextureCoordName; value: TextureGenParameter): UInt32 :=
z_BindTexGenParameterEXT_ovr_0(&unit, coord, value);
private static function z_BindTextureUnitParameterEXT_ovr_0(&unit: TextureUnit; value: VertexShaderTextureUnitParameter): UInt32;
external 'opengl32.dll' name 'glBindTextureUnitParameterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindTextureUnitParameterEXT(&unit: TextureUnit; value: VertexShaderTextureUnitParameter): UInt32 :=
z_BindTextureUnitParameterEXT_ovr_0(&unit, value);
private static function z_BindParameterEXT_ovr_0(value: VertexShaderParameterEXT): UInt32;
external 'opengl32.dll' name 'glBindParameterEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindParameterEXT(value: VertexShaderParameterEXT): UInt32 :=
z_BindParameterEXT_ovr_0(value);
private static function z_IsVariantEnabledEXT_ovr_0(id: UInt32; cap: VariantCapEXT): boolean;
external 'opengl32.dll' name 'glIsVariantEnabledEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVariantEnabledEXT(id: UInt32; cap: VariantCapEXT): boolean :=
z_IsVariantEnabledEXT_ovr_0(id, cap);
private static procedure z_GetVariantBooleanvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: boolean);
external 'opengl32.dll' name 'glGetVariantBooleanvEXT';
private static procedure z_GetVariantBooleanvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetVariantBooleanvEXT_ovr_0(id, value, data[0]) else
z_GetVariantBooleanvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean) :=
z_GetVariantBooleanvEXT_ovr_0(id, value, data);
private static procedure z_GetVariantBooleanvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetVariantBooleanvEXT_ovr_2(id, value, data);
private static procedure z_GetVariantIntegervEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: Int32);
external 'opengl32.dll' name 'glGetVariantIntegervEXT';
private static procedure z_GetVariantIntegervEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetVariantIntegervEXT_ovr_0(id, value, data[0]) else
z_GetVariantIntegervEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32) :=
z_GetVariantIntegervEXT_ovr_0(id, value, data);
private static procedure z_GetVariantIntegervEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetVariantIntegervEXT_ovr_2(id, value, data);
private static procedure z_GetVariantFloatvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: single);
external 'opengl32.dll' name 'glGetVariantFloatvEXT';
private static procedure z_GetVariantFloatvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetVariantFloatvEXT_ovr_0(id, value, data[0]) else
z_GetVariantFloatvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single) :=
z_GetVariantFloatvEXT_ovr_0(id, value, data);
private static procedure z_GetVariantFloatvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetVariantFloatvEXT_ovr_2(id, value, data);
private static procedure z_GetVariantPointervEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: IntPtr);
external 'opengl32.dll' name 'glGetVariantPointervEXT';
private static procedure z_GetVariantPointervEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetVariantPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; data: array of IntPtr) :=
if (data<>nil) and (data.Length<>0) then
z_GetVariantPointervEXT_ovr_0(id, value, data[0]) else
z_GetVariantPointervEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; var data: IntPtr) :=
z_GetVariantPointervEXT_ovr_0(id, value, data);
private static procedure z_GetVariantPointervEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: pointer);
external 'opengl32.dll' name 'glGetVariantPointervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; data: pointer) :=
z_GetVariantPointervEXT_ovr_2(id, value, data);
private static procedure z_GetInvariantBooleanvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: boolean);
external 'opengl32.dll' name 'glGetInvariantBooleanvEXT';
private static procedure z_GetInvariantBooleanvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetInvariantBooleanvEXT_ovr_0(id, value, data[0]) else
z_GetInvariantBooleanvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean) :=
z_GetInvariantBooleanvEXT_ovr_0(id, value, data);
private static procedure z_GetInvariantBooleanvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetInvariantBooleanvEXT_ovr_2(id, value, data);
private static procedure z_GetInvariantIntegervEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: Int32);
external 'opengl32.dll' name 'glGetInvariantIntegervEXT';
private static procedure z_GetInvariantIntegervEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetInvariantIntegervEXT_ovr_0(id, value, data[0]) else
z_GetInvariantIntegervEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32) :=
z_GetInvariantIntegervEXT_ovr_0(id, value, data);
private static procedure z_GetInvariantIntegervEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetInvariantIntegervEXT_ovr_2(id, value, data);
private static procedure z_GetInvariantFloatvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: single);
external 'opengl32.dll' name 'glGetInvariantFloatvEXT';
private static procedure z_GetInvariantFloatvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetInvariantFloatvEXT_ovr_0(id, value, data[0]) else
z_GetInvariantFloatvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single) :=
z_GetInvariantFloatvEXT_ovr_0(id, value, data);
private static procedure z_GetInvariantFloatvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetInvariantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetInvariantFloatvEXT_ovr_2(id, value, data);
private static procedure z_GetLocalConstantBooleanvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: boolean);
external 'opengl32.dll' name 'glGetLocalConstantBooleanvEXT';
private static procedure z_GetLocalConstantBooleanvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean) :=
if (data<>nil) and (data.Length<>0) then
z_GetLocalConstantBooleanvEXT_ovr_0(id, value, data[0]) else
z_GetLocalConstantBooleanvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean) :=
z_GetLocalConstantBooleanvEXT_ovr_0(id, value, data);
private static procedure z_GetLocalConstantBooleanvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantBooleanvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetLocalConstantBooleanvEXT_ovr_2(id, value, data);
private static procedure z_GetLocalConstantIntegervEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: Int32);
external 'opengl32.dll' name 'glGetLocalConstantIntegervEXT';
private static procedure z_GetLocalConstantIntegervEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32) :=
if (data<>nil) and (data.Length<>0) then
z_GetLocalConstantIntegervEXT_ovr_0(id, value, data[0]) else
z_GetLocalConstantIntegervEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32) :=
z_GetLocalConstantIntegervEXT_ovr_0(id, value, data);
private static procedure z_GetLocalConstantIntegervEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantIntegervEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetLocalConstantIntegervEXT_ovr_2(id, value, data);
private static procedure z_GetLocalConstantFloatvEXT_ovr_0(id: UInt32; value: GetVariantValueEXT; var data: single);
external 'opengl32.dll' name 'glGetLocalConstantFloatvEXT';
private static procedure z_GetLocalConstantFloatvEXT_ovr_0_anh0001(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single) :=
if (data<>nil) and (data.Length<>0) then
z_GetLocalConstantFloatvEXT_ovr_0(id, value, data[0]) else
z_GetLocalConstantFloatvEXT_ovr_0_anh0001(id, value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single) :=
z_GetLocalConstantFloatvEXT_ovr_0(id, value, data);
private static procedure z_GetLocalConstantFloatvEXT_ovr_2(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
external 'opengl32.dll' name 'glGetLocalConstantFloatvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr) :=
z_GetLocalConstantFloatvEXT_ovr_2(id, value, data);
end;
[PCUNotRestore]
glVertexWeightingEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexWeightfEXT_ovr_0(weight: single);
external 'opengl32.dll' name 'glVertexWeightfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfEXT(weight: single) :=
z_VertexWeightfEXT_ovr_0(weight);
private static procedure z_VertexWeightfvEXT_ovr_0(var weight: single);
external 'opengl32.dll' name 'glVertexWeightfvEXT';
private static procedure z_VertexWeightfvEXT_ovr_0_anh01(weight: IntPtr);
external 'opengl32.dll' name 'glVertexWeightfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(weight: array of single) :=
if (weight<>nil) and (weight.Length<>0) then
z_VertexWeightfvEXT_ovr_0(weight[0]) else
z_VertexWeightfvEXT_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(var weight: single) :=
z_VertexWeightfvEXT_ovr_0(weight);
private static procedure z_VertexWeightfvEXT_ovr_2(weight: IntPtr);
external 'opengl32.dll' name 'glVertexWeightfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(weight: IntPtr) :=
z_VertexWeightfvEXT_ovr_2(weight);
private static procedure z_VertexWeightPointerEXT_ovr_0(size: Int32; &type: VertexWeightPointerTypeEXT; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexWeightPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightPointerEXT(size: Int32; &type: VertexWeightPointerTypeEXT; stride: Int32; pointer: IntPtr) :=
z_VertexWeightPointerEXT_ovr_0(size, &type, stride, pointer);
end;
[PCUNotRestore]
glWin32KeyedMutexEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_AcquireKeyedMutexWin32EXT_ovr_0(memory: UInt32; key: UInt64; timeout: UInt32): boolean;
external 'opengl32.dll' name 'glAcquireKeyedMutexWin32EXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AcquireKeyedMutexWin32EXT(memory: UInt32; key: UInt64; timeout: UInt32): boolean :=
z_AcquireKeyedMutexWin32EXT_ovr_0(memory, key, timeout);
private static function z_ReleaseKeyedMutexWin32EXT_ovr_0(memory: UInt32; key: UInt64): boolean;
external 'opengl32.dll' name 'glReleaseKeyedMutexWin32EXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ReleaseKeyedMutexWin32EXT(memory: UInt32; key: UInt64): boolean :=
z_ReleaseKeyedMutexWin32EXT_ovr_0(memory, key);
end;
[PCUNotRestore]
glWindowRectanglesEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_WindowRectanglesEXT_ovr_0(mode: DummyEnum; count: Int32; var box: Int32);
external 'opengl32.dll' name 'glWindowRectanglesEXT';
private static procedure z_WindowRectanglesEXT_ovr_0_anh0001(mode: DummyEnum; count: Int32; box: IntPtr);
external 'opengl32.dll' name 'glWindowRectanglesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; box: array of Int32) :=
if (box<>nil) and (box.Length<>0) then
z_WindowRectanglesEXT_ovr_0(mode, count, box[0]) else
z_WindowRectanglesEXT_ovr_0_anh0001(mode, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; var box: Int32) :=
z_WindowRectanglesEXT_ovr_0(mode, count, box);
private static procedure z_WindowRectanglesEXT_ovr_2(mode: DummyEnum; count: Int32; box: IntPtr);
external 'opengl32.dll' name 'glWindowRectanglesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; box: IntPtr) :=
z_WindowRectanglesEXT_ovr_2(mode, count, box);
end;
[PCUNotRestore]
glX11SyncObjectEXT = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_ImportSyncEXT_ovr_0(external_sync_type: DummyEnum; external_sync: IntPtr; flags: DummyFlags): GLsync;
external 'opengl32.dll' name 'glImportSyncEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ImportSyncEXT(external_sync_type: DummyEnum; external_sync: IntPtr; flags: DummyFlags): GLsync :=
z_ImportSyncEXT_ovr_0(external_sync_type, external_sync, flags);
end;
[PCUNotRestore]
glFrameTerminatorGREMEDY = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FrameTerminatorGREMEDY_ovr_0;
external 'opengl32.dll' name 'glFrameTerminatorGREMEDY';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrameTerminatorGREMEDY :=
z_FrameTerminatorGREMEDY_ovr_0;
end;
[PCUNotRestore]
glStringMarkerGREMEDY = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_StringMarkerGREMEDY_ovr_0(len: Int32; string: IntPtr);
external 'opengl32.dll' name 'glStringMarkerGREMEDY';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StringMarkerGREMEDY(len: Int32; string: IntPtr) :=
z_StringMarkerGREMEDY_ovr_0(len, string);
end;
[PCUNotRestore]
glImageTransformHP = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ImageTransformParameteriHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: Int32);
external 'opengl32.dll' name 'glImageTransformParameteriHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameteriHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: Int32) :=
z_ImageTransformParameteriHP_ovr_0(target, pname, param);
private static procedure z_ImageTransformParameterfHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: single);
external 'opengl32.dll' name 'glImageTransformParameterfHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: single) :=
z_ImageTransformParameterfHP_ovr_0(target, pname, param);
private static procedure z_ImageTransformParameterivHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32);
external 'opengl32.dll' name 'glImageTransformParameterivHP';
private static procedure z_ImageTransformParameterivHP_ovr_0_anh0001(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glImageTransformParameterivHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ImageTransformParameterivHP_ovr_0(target, pname, ¶ms[0]) else
z_ImageTransformParameterivHP_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32) :=
z_ImageTransformParameterivHP_ovr_0(target, pname, ¶ms);
private static procedure z_ImageTransformParameterivHP_ovr_2(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glImageTransformParameterivHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr) :=
z_ImageTransformParameterivHP_ovr_2(target, pname, ¶ms);
private static procedure z_ImageTransformParameterfvHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single);
external 'opengl32.dll' name 'glImageTransformParameterfvHP';
private static procedure z_ImageTransformParameterfvHP_ovr_0_anh0001(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glImageTransformParameterfvHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ImageTransformParameterfvHP_ovr_0(target, pname, ¶ms[0]) else
z_ImageTransformParameterfvHP_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single) :=
z_ImageTransformParameterfvHP_ovr_0(target, pname, ¶ms);
private static procedure z_ImageTransformParameterfvHP_ovr_2(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glImageTransformParameterfvHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr) :=
z_ImageTransformParameterfvHP_ovr_2(target, pname, ¶ms);
private static procedure z_GetImageTransformParameterivHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetImageTransformParameterivHP';
private static procedure z_GetImageTransformParameterivHP_ovr_0_anh0001(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetImageTransformParameterivHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetImageTransformParameterivHP_ovr_0(target, pname, ¶ms[0]) else
z_GetImageTransformParameterivHP_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32) :=
z_GetImageTransformParameterivHP_ovr_0(target, pname, ¶ms);
private static procedure z_GetImageTransformParameterivHP_ovr_2(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetImageTransformParameterivHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr) :=
z_GetImageTransformParameterivHP_ovr_2(target, pname, ¶ms);
private static procedure z_GetImageTransformParameterfvHP_ovr_0(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single);
external 'opengl32.dll' name 'glGetImageTransformParameterfvHP';
private static procedure z_GetImageTransformParameterfvHP_ovr_0_anh0001(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetImageTransformParameterfvHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetImageTransformParameterfvHP_ovr_0(target, pname, ¶ms[0]) else
z_GetImageTransformParameterfvHP_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single) :=
z_GetImageTransformParameterfvHP_ovr_0(target, pname, ¶ms);
private static procedure z_GetImageTransformParameterfvHP_ovr_2(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetImageTransformParameterfvHP';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr) :=
z_GetImageTransformParameterfvHP_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glMultimodeDrawArraysIBM = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiModeDrawArraysIBM_ovr_0(var mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh010000(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh001000(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh011000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh000100(var mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh010100(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh001100(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_0_anh011100(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first[0], count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh000100(mode[0], first[0], IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh001000(mode[0], IntPtr.Zero, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh001100(mode[0], IntPtr.Zero, IntPtr.Zero, primcount, modestride) else
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh010000(IntPtr.Zero, first[0], count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh010100(IntPtr.Zero, first[0], IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh011100(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_1_anh010000(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_1_anh001000(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_1_anh011000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh001000(mode[0], IntPtr.Zero, count, primcount, modestride) else
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh010000(IntPtr.Zero, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_2(var mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_2_anh010000(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_2_anh001000(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_2_anh011000(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_2(mode[0], first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_2_anh001000(mode[0], IntPtr.Zero, count, primcount, modestride) else
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_2_anh010000(IntPtr.Zero, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_2_anh011000(IntPtr.Zero, IntPtr.Zero, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_3_anh010000(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_3_anh010100(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh000100(mode[0], first, IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh010000(IntPtr.Zero, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh010100(IntPtr.Zero, first, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_4_anh010000(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first, count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh010000(IntPtr.Zero, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_5_anh010000(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_2(mode[0], first, count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_2_anh010000(IntPtr.Zero, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_6(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_6_anh010000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_6_anh000100(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_6_anh010100(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_6(mode[0], first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_6_anh000100(mode[0], first, IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_6_anh010000(IntPtr.Zero, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_6_anh010100(IntPtr.Zero, first, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_7_anh010000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_6(mode[0], first, count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_6_anh010000(IntPtr.Zero, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_8(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_8_anh010000(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_8(mode[0], first, count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_8_anh010000(IntPtr.Zero, first, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode, first[0], count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh000100(mode, first[0], IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0_anh001000(mode, IntPtr.Zero, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh001100(mode, IntPtr.Zero, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh001000(mode, IntPtr.Zero, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_2(mode, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_2_anh001000(mode, IntPtr.Zero, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_0(mode, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_0_anh000100(mode, first, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_0(mode, first, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_2(mode, first, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_6(mode, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_6_anh000100(mode, first, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_6(mode, first, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_8(mode, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_18(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_18_anh001000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_18_anh000100(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_18_anh001100(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_18(mode, first[0], count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_18_anh000100(mode, first[0], IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_18_anh001000(mode, IntPtr.Zero, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_18_anh001100(mode, IntPtr.Zero, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_19_anh001000(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_18(mode, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_18_anh001000(mode, IntPtr.Zero, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_20(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_20_anh001000(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
if (first<>nil) and (first.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_20(mode, first[0], count, primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_20_anh001000(mode, IntPtr.Zero, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_18(mode, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_18_anh000100(mode, first, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_18(mode, first, count, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_20(mode, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_24(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
private static procedure z_MultiModeDrawArraysIBM_ovr_24_anh000100(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawArraysIBM_ovr_24(mode, first, count[0], primcount, modestride) else
z_MultiModeDrawArraysIBM_ovr_24_anh000100(mode, first, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_24(mode, first, count, primcount, modestride);
private static procedure z_MultiModeDrawArraysIBM_ovr_26(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawArraysIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawArraysIBM_ovr_26(mode, first, count, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_0(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0010000(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0110000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0000100(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0100100(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0010100(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_0_anh0110100(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count[0], &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0000100(mode[0], count[0], &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0010000(mode[0], IntPtr.Zero, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0010100(mode[0], IntPtr.Zero, &type, IntPtr.Zero, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0100000(IntPtr.Zero, count[0], &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0100100(IntPtr.Zero, count[0], &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0110000(IntPtr.Zero, IntPtr.Zero, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0110100(IntPtr.Zero, IntPtr.Zero, &type, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_1_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_1_anh0010000(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_1_anh0110000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0010000(mode[0], IntPtr.Zero, &type, indices, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0100000(IntPtr.Zero, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0110000(IntPtr.Zero, IntPtr.Zero, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_2(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_2_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_2_anh0010000(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_2_anh0110000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_2(mode[0], count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_2_anh0010000(mode[0], IntPtr.Zero, &type, indices, primcount, modestride) else
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_2_anh0100000(IntPtr.Zero, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_2_anh0110000(IntPtr.Zero, IntPtr.Zero, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_3_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_3_anh0000100(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_3_anh0100100(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0000100(mode[0], count, &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0100000(IntPtr.Zero, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0100100(IntPtr.Zero, count, &type, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_4_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count, &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0100000(IntPtr.Zero, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_5_anh0100000(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_2(mode[0], count, &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_2_anh0100000(IntPtr.Zero, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_6(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_6_anh0100000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_6_anh0000100(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_6_anh0100100(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_6(mode[0], count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_6_anh0000100(mode[0], count, &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_6_anh0100000(IntPtr.Zero, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_6_anh0100100(IntPtr.Zero, count, &type, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_7_anh0100000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_6(mode[0], count, &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_6_anh0100000(IntPtr.Zero, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_8(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_8_anh0100000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
if (mode<>nil) and (mode.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_8(mode[0], count, &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_8_anh0100000(IntPtr.Zero, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_9_anh0000100(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_9_anh0010100(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode, count[0], &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0000100(mode, count[0], &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0010000(mode, IntPtr.Zero, &type, indices, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_2(mode, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_2_anh0010000(mode, IntPtr.Zero, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_12_anh0000100(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_0(mode, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_0_anh0000100(mode, count, &type, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_0(mode, count, &type, indices, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_2(mode, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_15_anh0000100(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_6(mode, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_6_anh0000100(mode, count, &type, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_6(mode, count, &type, indices, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_8(mode, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_18(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_18_anh0010000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_18_anh0000100(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_18_anh0010100(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_18(mode, count[0], &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_18_anh0000100(mode, count[0], &type, IntPtr.Zero, primcount, modestride) else
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_18_anh0010000(mode, IntPtr.Zero, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_18_anh0010100(mode, IntPtr.Zero, &type, IntPtr.Zero, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_19_anh0010000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_18(mode, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_18_anh0010000(mode, IntPtr.Zero, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_20(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_20_anh0010000(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
if (count<>nil) and (count.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_20(mode, count[0], &type, indices, primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_20_anh0010000(mode, IntPtr.Zero, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_21_anh0000100(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_18(mode, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_18_anh0000100(mode, count, &type, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_18(mode, count, &type, indices, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_20(mode, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_24(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
private static procedure z_MultiModeDrawElementsIBM_ovr_24_anh0000100(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: IntPtr; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32) :=
if (indices<>nil) and (indices.Length<>0) then
z_MultiModeDrawElementsIBM_ovr_24(mode, count, &type, indices[0], primcount, modestride) else
z_MultiModeDrawElementsIBM_ovr_24_anh0000100(mode, count, &type, IntPtr.Zero, primcount, modestride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_24(mode, count, &type, indices, primcount, modestride);
private static procedure z_MultiModeDrawElementsIBM_ovr_26(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
external 'opengl32.dll' name 'glMultiModeDrawElementsIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32) :=
z_MultiModeDrawElementsIBM_ovr_26(mode, count, &type, indices, primcount, modestride);
end;
[PCUNotRestore]
glStaticDataIBM = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FlushStaticDataIBM_ovr_0(target: DummyEnum);
external 'opengl32.dll' name 'glFlushStaticDataIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushStaticDataIBM(target: DummyEnum) :=
z_FlushStaticDataIBM_ovr_0(target);
end;
[PCUNotRestore]
glVertexArrayListsIBM = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ColorPointerListIBM_ovr_0(size: Int32; &type: ColorPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glColorPointerListIBM';
private static procedure z_ColorPointerListIBM_ovr_0_anh000010(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glColorPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_ColorPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride) else
z_ColorPointerListIBM_ovr_0_anh000010(size, &type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_ColorPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
private static procedure z_ColorPointerListIBM_ovr_2(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glColorPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_ColorPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
private static procedure z_SecondaryColorPointerListIBM_ovr_0(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glSecondaryColorPointerListIBM';
private static procedure z_SecondaryColorPointerListIBM_ovr_0_anh000010(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glSecondaryColorPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_SecondaryColorPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride) else
z_SecondaryColorPointerListIBM_ovr_0_anh000010(size, &type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_SecondaryColorPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
private static procedure z_SecondaryColorPointerListIBM_ovr_2(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glSecondaryColorPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_SecondaryColorPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
private static procedure z_EdgeFlagPointerListIBM_ovr_0(stride: Int32; var pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glEdgeFlagPointerListIBM';
private static procedure z_EdgeFlagPointerListIBM_ovr_0_anh0010(stride: Int32; pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glEdgeFlagPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerListIBM(stride: Int32; pointer: array of array of Byte; ptrstride: Int32);
begin
var par_2_temp_arr1 := pointer?.ConvertAll(arr_el1->begin
if (arr_el1=nil) or (arr_el1.Length=0) then
Result := IntPtr.Zero else
begin
var l := Marshal.SizeOf&<Byte>*arr_el1.Length;
Result := Marshal.AllocHGlobal(l);
Marshal.Copy(arr_el1,0,Result,l);
end;
end);
if (par_2_temp_arr1<>nil) and (par_2_temp_arr1.Length<>0) then
z_EdgeFlagPointerListIBM_ovr_0(stride, par_2_temp_arr1[0], ptrstride) else
z_EdgeFlagPointerListIBM_ovr_0_anh0010(stride, IntPtr.Zero, ptrstride);
foreach var arr_el1 in par_2_temp_arr1 do Marshal.FreeHGlobal(arr_el1);
end;
private static procedure z_EdgeFlagPointerListIBM_ovr_1_anh0010(stride: Int32; pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glEdgeFlagPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerListIBM(stride: Int32; pointer: array of IntPtr; ptrstride: Int32) :=
if (pointer<>nil) and (pointer.Length<>0) then
z_EdgeFlagPointerListIBM_ovr_0(stride, pointer[0], ptrstride) else
z_EdgeFlagPointerListIBM_ovr_0_anh0010(stride, IntPtr.Zero, ptrstride);
private static procedure z_EdgeFlagPointerListIBM_ovr_2(stride: Int32; pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glEdgeFlagPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerListIBM(stride: Int32; pointer: IntPtr; ptrstride: Int32) :=
z_EdgeFlagPointerListIBM_ovr_2(stride, pointer, ptrstride);
private static procedure z_FogCoordPointerListIBM_ovr_0(&type: FogPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glFogCoordPointerListIBM';
private static procedure z_FogCoordPointerListIBM_ovr_0_anh00010(&type: FogPointerTypeIBM; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glFogCoordPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_FogCoordPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride) else
z_FogCoordPointerListIBM_ovr_0_anh00010(&type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_FogCoordPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
private static procedure z_FogCoordPointerListIBM_ovr_2(&type: FogPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glFogCoordPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_FogCoordPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
private static procedure z_IndexPointerListIBM_ovr_0(&type: IndexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glIndexPointerListIBM';
private static procedure z_IndexPointerListIBM_ovr_0_anh00010(&type: IndexPointerType; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glIndexPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_IndexPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride) else
z_IndexPointerListIBM_ovr_0_anh00010(&type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_IndexPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
private static procedure z_IndexPointerListIBM_ovr_2(&type: IndexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glIndexPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_IndexPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
private static procedure z_NormalPointerListIBM_ovr_0(&type: NormalPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glNormalPointerListIBM';
private static procedure z_NormalPointerListIBM_ovr_0_anh00010(&type: NormalPointerType; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glNormalPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_NormalPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride) else
z_NormalPointerListIBM_ovr_0_anh00010(&type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_NormalPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
private static procedure z_NormalPointerListIBM_ovr_2(&type: NormalPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glNormalPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_NormalPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
private static procedure z_TexCoordPointerListIBM_ovr_0(size: Int32; &type: TexCoordPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glTexCoordPointerListIBM';
private static procedure z_TexCoordPointerListIBM_ovr_0_anh000010(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glTexCoordPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_TexCoordPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride) else
z_TexCoordPointerListIBM_ovr_0_anh000010(size, &type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_TexCoordPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
private static procedure z_TexCoordPointerListIBM_ovr_2(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glTexCoordPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_TexCoordPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
private static procedure z_VertexPointerListIBM_ovr_0(size: Int32; &type: VertexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glVertexPointerListIBM';
private static procedure z_VertexPointerListIBM_ovr_0_anh000010(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: IntPtr; ptrstride: Int32);
external 'opengl32.dll' name 'glVertexPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_VertexPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride) else
z_VertexPointerListIBM_ovr_0_anh000010(size, &type, stride, IntPtr.Zero, ptrstride);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32) :=
z_VertexPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
private static procedure z_VertexPointerListIBM_ovr_2(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
external 'opengl32.dll' name 'glVertexPointerListIBM';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32) :=
z_VertexPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
end;
[PCUNotRestore]
glBlendFuncSeparateINGR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendFuncSeparateINGR_ovr_0(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor);
external 'opengl32.dll' name 'glBlendFuncSeparateINGR';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateINGR(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor) :=
z_BlendFuncSeparateINGR_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
end;
[PCUNotRestore]
glFramebufferCMAAINTEL = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ApplyFramebufferAttachmentCMAAINTEL_ovr_0;
external 'opengl32.dll' name 'glApplyFramebufferAttachmentCMAAINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ApplyFramebufferAttachmentCMAAINTEL :=
z_ApplyFramebufferAttachmentCMAAINTEL_ovr_0;
end;
[PCUNotRestore]
glMapTextureINTEL = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SyncTextureINTEL_ovr_0(texture: UInt32);
external 'opengl32.dll' name 'glSyncTextureINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SyncTextureINTEL(texture: UInt32) :=
z_SyncTextureINTEL_ovr_0(texture);
private static procedure z_UnmapTexture2DINTEL_ovr_0(texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glUnmapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnmapTexture2DINTEL(texture: UInt32; level: Int32) :=
z_UnmapTexture2DINTEL_ovr_0(texture, level);
private static function z_MapTexture2DINTEL_ovr_0(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; var layout: DummyEnum): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
private static function z_MapTexture2DINTEL_ovr_0_anh000010(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
private static function z_MapTexture2DINTEL_ovr_0_anh000001(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
private static function z_MapTexture2DINTEL_ovr_0_anh000011(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; layout: array of DummyEnum): IntPtr :=
if (stride<>nil) and (stride.Length<>0) then
if (layout<>nil) and (layout.Length<>0) then
z_MapTexture2DINTEL_ovr_0(texture, level, access, stride[0], layout[0]) else
z_MapTexture2DINTEL_ovr_0_anh000001(texture, level, access, stride[0], IntPtr.Zero) else
if (layout<>nil) and (layout.Length<>0) then
z_MapTexture2DINTEL_ovr_0_anh000010(texture, level, access, IntPtr.Zero, layout[0]) else
z_MapTexture2DINTEL_ovr_0_anh000011(texture, level, access, IntPtr.Zero, IntPtr.Zero);
private static function z_MapTexture2DINTEL_ovr_1_anh000010(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; var layout: DummyEnum): IntPtr :=
if (stride<>nil) and (stride.Length<>0) then
z_MapTexture2DINTEL_ovr_0(texture, level, access, stride[0], layout) else
z_MapTexture2DINTEL_ovr_0_anh000010(texture, level, access, IntPtr.Zero, layout);
private static function z_MapTexture2DINTEL_ovr_2(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
private static function z_MapTexture2DINTEL_ovr_2_anh000010(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; layout: IntPtr): IntPtr :=
if (stride<>nil) and (stride.Length<>0) then
z_MapTexture2DINTEL_ovr_2(texture, level, access, stride[0], layout) else
z_MapTexture2DINTEL_ovr_2_anh000010(texture, level, access, IntPtr.Zero, layout);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: array of DummyEnum): IntPtr :=
if (layout<>nil) and (layout.Length<>0) then
z_MapTexture2DINTEL_ovr_0(texture, level, access, stride, layout[0]) else
z_MapTexture2DINTEL_ovr_0_anh000001(texture, level, access, stride, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; var layout: DummyEnum): IntPtr :=
z_MapTexture2DINTEL_ovr_0(texture, level, access, stride, layout);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: IntPtr): IntPtr :=
z_MapTexture2DINTEL_ovr_2(texture, level, access, stride, layout);
private static function z_MapTexture2DINTEL_ovr_6(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
private static function z_MapTexture2DINTEL_ovr_6_anh000001(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: array of DummyEnum): IntPtr :=
if (layout<>nil) and (layout.Length<>0) then
z_MapTexture2DINTEL_ovr_6(texture, level, access, stride, layout[0]) else
z_MapTexture2DINTEL_ovr_6_anh000001(texture, level, access, stride, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr :=
z_MapTexture2DINTEL_ovr_6(texture, level, access, stride, layout);
private static function z_MapTexture2DINTEL_ovr_8(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr;
external 'opengl32.dll' name 'glMapTexture2DINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr :=
z_MapTexture2DINTEL_ovr_8(texture, level, access, stride, layout);
end;
[PCUNotRestore]
glParallelArraysINTEL = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexPointervINTEL_ovr_0(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
external 'opengl32.dll' name 'glVertexPointervINTEL';
private static procedure z_VertexPointervINTEL_ovr_0_anh0001(size: Int32; &type: VertexPointerType; _pointer: IntPtr);
external 'opengl32.dll' name 'glVertexPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_VertexPointervINTEL_ovr_0(size, &type, _pointer[0]) else
z_VertexPointervINTEL_ovr_0_anh0001(size, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr) :=
z_VertexPointervINTEL_ovr_0(size, &type, _pointer);
private static procedure z_VertexPointervINTEL_ovr_2(size: Int32; &type: VertexPointerType; _pointer: pointer);
external 'opengl32.dll' name 'glVertexPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer) :=
z_VertexPointervINTEL_ovr_2(size, &type, _pointer);
private static procedure z_NormalPointervINTEL_ovr_0(&type: NormalPointerType; var _pointer: IntPtr);
external 'opengl32.dll' name 'glNormalPointervINTEL';
private static procedure z_NormalPointervINTEL_ovr_0_anh001(&type: NormalPointerType; _pointer: IntPtr);
external 'opengl32.dll' name 'glNormalPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_NormalPointervINTEL_ovr_0(&type, _pointer[0]) else
z_NormalPointervINTEL_ovr_0_anh001(&type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; var _pointer: IntPtr) :=
z_NormalPointervINTEL_ovr_0(&type, _pointer);
private static procedure z_NormalPointervINTEL_ovr_2(&type: NormalPointerType; _pointer: pointer);
external 'opengl32.dll' name 'glNormalPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; _pointer: pointer) :=
z_NormalPointervINTEL_ovr_2(&type, _pointer);
private static procedure z_ColorPointervINTEL_ovr_0(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
external 'opengl32.dll' name 'glColorPointervINTEL';
private static procedure z_ColorPointervINTEL_ovr_0_anh0001(size: Int32; &type: VertexPointerType; _pointer: IntPtr);
external 'opengl32.dll' name 'glColorPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_ColorPointervINTEL_ovr_0(size, &type, _pointer[0]) else
z_ColorPointervINTEL_ovr_0_anh0001(size, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr) :=
z_ColorPointervINTEL_ovr_0(size, &type, _pointer);
private static procedure z_ColorPointervINTEL_ovr_2(size: Int32; &type: VertexPointerType; _pointer: pointer);
external 'opengl32.dll' name 'glColorPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer) :=
z_ColorPointervINTEL_ovr_2(size, &type, _pointer);
private static procedure z_TexCoordPointervINTEL_ovr_0(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
external 'opengl32.dll' name 'glTexCoordPointervINTEL';
private static procedure z_TexCoordPointervINTEL_ovr_0_anh0001(size: Int32; &type: VertexPointerType; _pointer: IntPtr);
external 'opengl32.dll' name 'glTexCoordPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_TexCoordPointervINTEL_ovr_0(size, &type, _pointer[0]) else
z_TexCoordPointervINTEL_ovr_0_anh0001(size, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr) :=
z_TexCoordPointervINTEL_ovr_0(size, &type, _pointer);
private static procedure z_TexCoordPointervINTEL_ovr_2(size: Int32; &type: VertexPointerType; _pointer: pointer);
external 'opengl32.dll' name 'glTexCoordPointervINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer) :=
z_TexCoordPointervINTEL_ovr_2(size, &type, _pointer);
end;
[PCUNotRestore]
glPerformanceQueryINTEL = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginPerfQueryINTEL_ovr_0(queryHandle: PerfQueryHandleINTEL);
external 'opengl32.dll' name 'glBeginPerfQueryINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginPerfQueryINTEL(queryHandle: PerfQueryHandleINTEL) :=
z_BeginPerfQueryINTEL_ovr_0(queryHandle);
private static procedure z_CreatePerfQueryINTEL_ovr_0(queryId: PerfQueryIdINTEL; var queryHandle: PerfQueryHandleINTEL);
external 'opengl32.dll' name 'glCreatePerfQueryINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreatePerfQueryINTEL(queryId: PerfQueryIdINTEL; var queryHandle: PerfQueryHandleINTEL) :=
z_CreatePerfQueryINTEL_ovr_0(queryId, queryHandle);
private static procedure z_CreatePerfQueryINTEL_ovr_1(queryId: PerfQueryIdINTEL; queryHandle: IntPtr);
external 'opengl32.dll' name 'glCreatePerfQueryINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreatePerfQueryINTEL(queryId: PerfQueryIdINTEL; queryHandle: IntPtr) :=
z_CreatePerfQueryINTEL_ovr_1(queryId, queryHandle);
private static procedure z_DeletePerfQueryINTEL_ovr_0(queryHandle: PerfQueryHandleINTEL);
external 'opengl32.dll' name 'glDeletePerfQueryINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfQueryINTEL(queryHandle: PerfQueryHandleINTEL) :=
z_DeletePerfQueryINTEL_ovr_0(queryHandle);
private static procedure z_EndPerfQueryINTEL_ovr_0(queryHandle: PerfQueryHandleINTEL);
external 'opengl32.dll' name 'glEndPerfQueryINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndPerfQueryINTEL(queryHandle: PerfQueryHandleINTEL) :=
z_EndPerfQueryINTEL_ovr_0(queryHandle);
private static procedure z_GetFirstPerfQueryIdINTEL_ovr_0(var queryId: PerfQueryIdINTEL);
external 'opengl32.dll' name 'glGetFirstPerfQueryIdINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFirstPerfQueryIdINTEL(var queryId: PerfQueryIdINTEL) :=
z_GetFirstPerfQueryIdINTEL_ovr_0(queryId);
private static procedure z_GetFirstPerfQueryIdINTEL_ovr_1(queryId: IntPtr);
external 'opengl32.dll' name 'glGetFirstPerfQueryIdINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFirstPerfQueryIdINTEL(queryId: IntPtr) :=
z_GetFirstPerfQueryIdINTEL_ovr_1(queryId);
private static procedure z_GetNextPerfQueryIdINTEL_ovr_0(queryId: PerfQueryIdINTEL; nextQueryId: PerfQueryIdINTEL);
external 'opengl32.dll' name 'glGetNextPerfQueryIdINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNextPerfQueryIdINTEL(queryId: PerfQueryIdINTEL; nextQueryId: PerfQueryIdINTEL) :=
z_GetNextPerfQueryIdINTEL_ovr_0(queryId, nextQueryId);
private static procedure z_GetNextPerfQueryIdINTEL_ovr_1(queryId: PerfQueryIdINTEL; nextQueryId: IntPtr);
external 'opengl32.dll' name 'glGetNextPerfQueryIdINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNextPerfQueryIdINTEL(queryId: PerfQueryIdINTEL; nextQueryId: IntPtr) :=
z_GetNextPerfQueryIdINTEL_ovr_1(queryId, nextQueryId);
private static procedure z_GetPerfCounterInfoINTEL_ovr_0(queryId: PerfQueryIdINTEL; counterId: UInt32; counterNameLength: UInt32; counterName: IntPtr; counterDescLength: UInt32; counterDesc: IntPtr; var counterOffset: UInt32; var counterDataSize: UInt32; var counterTypeEnum: UInt32; var counterDataTypeEnum: UInt32; var rawCounterMaxValue: UInt64);
external 'opengl32.dll' name 'glGetPerfCounterInfoINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfCounterInfoINTEL(queryId: PerfQueryIdINTEL; counterId: UInt32; counterNameLength: UInt32; counterName: IntPtr; counterDescLength: UInt32; counterDesc: IntPtr; var counterOffset: UInt32; var counterDataSize: UInt32; var counterTypeEnum: UInt32; var counterDataTypeEnum: UInt32; var rawCounterMaxValue: UInt64) :=
z_GetPerfCounterInfoINTEL_ovr_0(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
private static procedure z_GetPerfCounterInfoINTEL_ovr_1(queryId: PerfQueryIdINTEL; counterId: UInt32; counterNameLength: UInt32; counterName: IntPtr; counterDescLength: UInt32; counterDesc: IntPtr; counterOffset: IntPtr; counterDataSize: IntPtr; counterTypeEnum: IntPtr; counterDataTypeEnum: IntPtr; rawCounterMaxValue: IntPtr);
external 'opengl32.dll' name 'glGetPerfCounterInfoINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfCounterInfoINTEL(queryId: PerfQueryIdINTEL; counterId: UInt32; counterNameLength: UInt32; counterName: IntPtr; counterDescLength: UInt32; counterDesc: IntPtr; counterOffset: IntPtr; counterDataSize: IntPtr; counterTypeEnum: IntPtr; counterDataTypeEnum: IntPtr; rawCounterMaxValue: IntPtr) :=
z_GetPerfCounterInfoINTEL_ovr_1(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
private static procedure z_GetPerfQueryDataINTEL_ovr_0(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; var bytesWritten: UInt32);
external 'opengl32.dll' name 'glGetPerfQueryDataINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryDataINTEL(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; var bytesWritten: UInt32) :=
z_GetPerfQueryDataINTEL_ovr_0(queryHandle, flags, dataSize, data, bytesWritten);
private static procedure z_GetPerfQueryDataINTEL_ovr_1(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
external 'opengl32.dll' name 'glGetPerfQueryDataINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryDataINTEL(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr) :=
z_GetPerfQueryDataINTEL_ovr_1(queryHandle, flags, dataSize, data, bytesWritten);
private static procedure z_GetPerfQueryIdByNameINTEL_ovr_0(queryName: IntPtr; var queryId: PerfQueryIdINTEL);
external 'opengl32.dll' name 'glGetPerfQueryIdByNameINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryIdByNameINTEL(queryName: string; var queryId: PerfQueryIdINTEL);
begin
var par_1_str_ptr := Marshal.StringToHGlobalAnsi(queryName);
z_GetPerfQueryIdByNameINTEL_ovr_0(par_1_str_ptr, queryId);
Marshal.FreeHGlobal(par_1_str_ptr);
end;
private static procedure z_GetPerfQueryIdByNameINTEL_ovr_1(queryName: IntPtr; queryId: IntPtr);
external 'opengl32.dll' name 'glGetPerfQueryIdByNameINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryIdByNameINTEL(queryName: string; queryId: IntPtr);
begin
var par_1_str_ptr := Marshal.StringToHGlobalAnsi(queryName);
z_GetPerfQueryIdByNameINTEL_ovr_1(par_1_str_ptr, queryId);
Marshal.FreeHGlobal(par_1_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryIdByNameINTEL(queryName: IntPtr; var queryId: PerfQueryIdINTEL) :=
z_GetPerfQueryIdByNameINTEL_ovr_0(queryName, queryId);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryIdByNameINTEL(queryName: IntPtr; queryId: IntPtr) :=
z_GetPerfQueryIdByNameINTEL_ovr_1(queryName, queryId);
private static procedure z_GetPerfQueryInfoINTEL_ovr_0(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; var dataSize: UInt32; var noCounters: UInt32; var noInstances: UInt32; var capsMask: PerfQueryCapFlagsINTEL);
external 'opengl32.dll' name 'glGetPerfQueryInfoINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryInfoINTEL(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; var dataSize: UInt32; var noCounters: UInt32; var noInstances: UInt32; var capsMask: PerfQueryCapFlagsINTEL) :=
z_GetPerfQueryInfoINTEL_ovr_0(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
private static procedure z_GetPerfQueryInfoINTEL_ovr_1(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; dataSize: IntPtr; noCounters: IntPtr; noInstances: IntPtr; capsMask: IntPtr);
external 'opengl32.dll' name 'glGetPerfQueryInfoINTEL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryInfoINTEL(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; dataSize: IntPtr; noCounters: IntPtr; noInstances: IntPtr; capsMask: IntPtr) :=
z_GetPerfQueryInfoINTEL_ovr_1(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
end;
[PCUNotRestore]
glBlendEquationAdvancedKHR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendBarrierKHR_ovr_0;
external 'opengl32.dll' name 'glBlendBarrierKHR';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendBarrierKHR :=
z_BlendBarrierKHR_ovr_0;
end;
[PCUNotRestore]
glDebugKHR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DebugMessageControl_ovr_0(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControl';
private static procedure z_DebugMessageControl_ovr_0_anh0000010(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControl';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean) :=
if (ids<>nil) and (ids.Length<>0) then
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids[0], enabled) else
z_DebugMessageControl_ovr_0_anh0000010(source, &type, severity, count, IntPtr.Zero, enabled);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean) :=
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids, enabled);
private static procedure z_DebugMessageControl_ovr_2(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
external 'opengl32.dll' name 'glDebugMessageControl';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean) :=
z_DebugMessageControl_ovr_2(source, &type, severity, count, ids, enabled);
private static procedure z_DebugMessageInsert_ovr_0(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr);
external 'opengl32.dll' name 'glDebugMessageInsert';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsert(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: string);
begin
var par_6_str_ptr := Marshal.StringToHGlobalAnsi(buf);
z_DebugMessageInsert_ovr_0(source, &type, id, severity, length, par_6_str_ptr);
Marshal.FreeHGlobal(par_6_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageInsert(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr) :=
z_DebugMessageInsert_ovr_0(source, &type, id, severity, length, buf);
private static procedure z_DebugMessageCallback_ovr_0(callback: GLDEBUGPROC; userParam: IntPtr);
external 'opengl32.dll' name 'glDebugMessageCallback';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallback(callback: GLDEBUGPROC; userParam: IntPtr) :=
z_DebugMessageCallback_ovr_0(callback, userParam);
private static function z_GetDebugMessageLog_ovr_0(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLog';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLog(count: UInt32; bufSize: Int32; var sources: DebugSource; var types: DebugType; var ids: UInt32; var severities: DebugSeverity; var lengths: Int32; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLog_ovr_0(count, bufSize, sources, types, ids, severities, lengths, messageLog);
private static function z_GetDebugMessageLog_ovr_1(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32;
external 'opengl32.dll' name 'glGetDebugMessageLog';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLog(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32 :=
z_GetDebugMessageLog_ovr_1(count, bufSize, sources, types, ids, severities, lengths, messageLog);
private static procedure z_PushDebugGroup_ovr_0(source: DebugSource; id: UInt32; length: Int32; message: IntPtr);
external 'opengl32.dll' name 'glPushDebugGroup';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushDebugGroup(source: DebugSource; id: UInt32; length: Int32; message: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(message);
z_PushDebugGroup_ovr_0(source, id, length, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushDebugGroup(source: DebugSource; id: UInt32; length: Int32; message: IntPtr) :=
z_PushDebugGroup_ovr_0(source, id, length, message);
private static procedure z_PopDebugGroup_ovr_0;
external 'opengl32.dll' name 'glPopDebugGroup';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopDebugGroup :=
z_PopDebugGroup_ovr_0;
private static procedure z_ObjectLabel_ovr_0(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glObjectLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectLabel(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: string);
begin
var par_4_str_ptr := Marshal.StringToHGlobalAnsi(&label);
z_ObjectLabel_ovr_0(identifier, name, length, par_4_str_ptr);
Marshal.FreeHGlobal(par_4_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectLabel(identifier: ObjectIdentifier; name: UInt32; length: Int32; &label: IntPtr) :=
z_ObjectLabel_ovr_0(identifier, name, length, &label);
private static procedure z_GetObjectLabel_ovr_0(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabel';
private static procedure z_GetObjectLabel_ovr_0_anh000010(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: array of Int32; &label: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length[0], &label) else
z_GetObjectLabel_ovr_0_anh000010(identifier, name, bufSize, IntPtr.Zero, &label);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr) :=
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length, &label);
private static procedure z_GetObjectLabel_ovr_2(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr) :=
z_GetObjectLabel_ovr_2(identifier, name, bufSize, length, &label);
private static procedure z_ObjectPtrLabel_ovr_0(ptr: IntPtr; length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glObjectPtrLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectPtrLabel(ptr: IntPtr; length: Int32; &label: string);
begin
var par_3_str_ptr := Marshal.StringToHGlobalAnsi(&label);
z_ObjectPtrLabel_ovr_0(ptr, length, par_3_str_ptr);
Marshal.FreeHGlobal(par_3_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ObjectPtrLabel(ptr: IntPtr; length: Int32; &label: IntPtr) :=
z_ObjectPtrLabel_ovr_0(ptr, length, &label);
private static procedure z_GetObjectPtrLabel_ovr_0(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectPtrLabel';
private static procedure z_GetObjectPtrLabel_ovr_0_anh00010(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectPtrLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; length: array of Int32; &label: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length[0], &label) else
z_GetObjectPtrLabel_ovr_0_anh00010(ptr, bufSize, IntPtr.Zero, &label);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr) :=
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length, &label);
private static procedure z_GetObjectPtrLabel_ovr_2(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr);
external 'opengl32.dll' name 'glGetObjectPtrLabel';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; length: IntPtr; &label: IntPtr) :=
z_GetObjectPtrLabel_ovr_2(ptr, bufSize, length, &label);
private static procedure z_GetPointerv_ovr_0(pname: GetPointervPName; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointerv';
private static procedure z_GetPointerv_ovr_0_anh001(pname: GetPointervPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: array of IntPtr) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPointerv_ovr_0(pname, ¶ms[0]) else
z_GetPointerv_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; var ¶ms: IntPtr) :=
z_GetPointerv_ovr_0(pname, ¶ms);
private static procedure z_GetPointerv_ovr_2(pname: GetPointervPName; ¶ms: pointer);
external 'opengl32.dll' name 'glGetPointerv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: pointer) :=
z_GetPointerv_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glRobustnessKHR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetGraphicsResetStatus_ovr_0: GraphicsResetStatus;
external 'opengl32.dll' name 'glGetGraphicsResetStatus';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetGraphicsResetStatus: GraphicsResetStatus :=
z_GetGraphicsResetStatus_ovr_0;
private static procedure z_ReadnPixels_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr);
external 'opengl32.dll' name 'glReadnPixels';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadnPixels(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr) :=
z_ReadnPixels_ovr_0(x, y, width, height, format, &type, bufSize, data);
private static procedure z_GetnUniformfv_ovr_0(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetnUniformfv';
private static procedure z_GetnUniformfv_ovr_0_anh00001(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformfv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single) :=
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformfv_ovr_2(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformfv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformfv_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformiv_ovr_0(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetnUniformiv';
private static procedure z_GetnUniformiv_ovr_0_anh00001(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformiv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32) :=
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformiv_ovr_2(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformiv_ovr_2(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformuiv_ovr_0(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetnUniformuiv';
private static procedure z_GetnUniformuiv_ovr_0_anh00001(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms[0]) else
z_GetnUniformuiv_ovr_0_anh00001(&program, location, bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32) :=
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms);
private static procedure z_GetnUniformuiv_ovr_2(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetnUniformuiv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: IntPtr) :=
z_GetnUniformuiv_ovr_2(&program, location, bufSize, ¶ms);
end;
[PCUNotRestore]
glParallelShaderCompileKHR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MaxShaderCompilerThreadsKHR_ovr_0(count: UInt32);
external 'opengl32.dll' name 'glMaxShaderCompilerThreadsKHR';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaxShaderCompilerThreadsKHR(count: UInt32) :=
z_MaxShaderCompilerThreadsKHR_ovr_0(count);
end;
[PCUNotRestore]
glFramebufferFlipYMESA = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferParameteriMESA_ovr_0(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32);
external 'opengl32.dll' name 'glFramebufferParameteriMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferParameteriMESA(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32) :=
z_FramebufferParameteriMESA_ovr_0(target, pname, param);
private static procedure z_GetFramebufferParameterivMESA_ovr_0(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFramebufferParameterivMESA';
private static procedure z_GetFramebufferParameterivMESA_ovr_0_anh0001(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFramebufferParameterivMESA_ovr_0(target, pname, ¶ms[0]) else
z_GetFramebufferParameterivMESA_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32) :=
z_GetFramebufferParameterivMESA_ovr_0(target, pname, ¶ms);
private static procedure z_GetFramebufferParameterivMESA_ovr_2(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFramebufferParameterivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr) :=
z_GetFramebufferParameterivMESA_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glResizeBuffersMESA = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ResizeBuffersMESA_ovr_0;
external 'opengl32.dll' name 'glResizeBuffersMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResizeBuffersMESA :=
z_ResizeBuffersMESA_ovr_0;
end;
[PCUNotRestore]
glWindowPosMESA = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_WindowPos2dMESA_ovr_0(x: real; y: real);
external 'opengl32.dll' name 'glWindowPos2dMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dMESA(x: real; y: real) :=
z_WindowPos2dMESA_ovr_0(x, y);
private static procedure z_WindowPos2dvMESA_ovr_0(var v: real);
external 'opengl32.dll' name 'glWindowPos2dvMESA';
private static procedure z_WindowPos2dvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2dvMESA_ovr_0(v[0]) else
z_WindowPos2dvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(var v: real) :=
z_WindowPos2dvMESA_ovr_0(v);
private static procedure z_WindowPos2dvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(v: IntPtr) :=
z_WindowPos2dvMESA_ovr_2(v);
private static procedure z_WindowPos2fMESA_ovr_0(x: single; y: single);
external 'opengl32.dll' name 'glWindowPos2fMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fMESA(x: single; y: single) :=
z_WindowPos2fMESA_ovr_0(x, y);
private static procedure z_WindowPos2fvMESA_ovr_0(var v: single);
external 'opengl32.dll' name 'glWindowPos2fvMESA';
private static procedure z_WindowPos2fvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2fvMESA_ovr_0(v[0]) else
z_WindowPos2fvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(var v: single) :=
z_WindowPos2fvMESA_ovr_0(v);
private static procedure z_WindowPos2fvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(v: IntPtr) :=
z_WindowPos2fvMESA_ovr_2(v);
private static procedure z_WindowPos2iMESA_ovr_0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glWindowPos2iMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iMESA(x: Int32; y: Int32) :=
z_WindowPos2iMESA_ovr_0(x, y);
private static procedure z_WindowPos2ivMESA_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glWindowPos2ivMESA';
private static procedure z_WindowPos2ivMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2ivMESA_ovr_0(v[0]) else
z_WindowPos2ivMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(var v: Int32) :=
z_WindowPos2ivMESA_ovr_0(v);
private static procedure z_WindowPos2ivMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(v: IntPtr) :=
z_WindowPos2ivMESA_ovr_2(v);
private static procedure z_WindowPos2sMESA_ovr_0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glWindowPos2sMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sMESA(x: Int16; y: Int16) :=
z_WindowPos2sMESA_ovr_0(x, y);
private static procedure z_WindowPos2svMESA_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glWindowPos2svMESA';
private static procedure z_WindowPos2svMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos2svMESA_ovr_0(v[0]) else
z_WindowPos2svMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(var v: Int16) :=
z_WindowPos2svMESA_ovr_0(v);
private static procedure z_WindowPos2svMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos2svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(v: IntPtr) :=
z_WindowPos2svMESA_ovr_2(v);
private static procedure z_WindowPos3dMESA_ovr_0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glWindowPos3dMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dMESA(x: real; y: real; z: real) :=
z_WindowPos3dMESA_ovr_0(x, y, z);
private static procedure z_WindowPos3dvMESA_ovr_0(var v: real);
external 'opengl32.dll' name 'glWindowPos3dvMESA';
private static procedure z_WindowPos3dvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3dvMESA_ovr_0(v[0]) else
z_WindowPos3dvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(var v: real) :=
z_WindowPos3dvMESA_ovr_0(v);
private static procedure z_WindowPos3dvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(v: IntPtr) :=
z_WindowPos3dvMESA_ovr_2(v);
private static procedure z_WindowPos3fMESA_ovr_0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glWindowPos3fMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fMESA(x: single; y: single; z: single) :=
z_WindowPos3fMESA_ovr_0(x, y, z);
private static procedure z_WindowPos3fvMESA_ovr_0(var v: single);
external 'opengl32.dll' name 'glWindowPos3fvMESA';
private static procedure z_WindowPos3fvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3fvMESA_ovr_0(v[0]) else
z_WindowPos3fvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(var v: single) :=
z_WindowPos3fvMESA_ovr_0(v);
private static procedure z_WindowPos3fvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(v: IntPtr) :=
z_WindowPos3fvMESA_ovr_2(v);
private static procedure z_WindowPos3iMESA_ovr_0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glWindowPos3iMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iMESA(x: Int32; y: Int32; z: Int32) :=
z_WindowPos3iMESA_ovr_0(x, y, z);
private static procedure z_WindowPos3ivMESA_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glWindowPos3ivMESA';
private static procedure z_WindowPos3ivMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3ivMESA_ovr_0(v[0]) else
z_WindowPos3ivMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(var v: Int32) :=
z_WindowPos3ivMESA_ovr_0(v);
private static procedure z_WindowPos3ivMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(v: IntPtr) :=
z_WindowPos3ivMESA_ovr_2(v);
private static procedure z_WindowPos3sMESA_ovr_0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glWindowPos3sMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sMESA(x: Int16; y: Int16; z: Int16) :=
z_WindowPos3sMESA_ovr_0(x, y, z);
private static procedure z_WindowPos3svMESA_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glWindowPos3svMESA';
private static procedure z_WindowPos3svMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos3svMESA_ovr_0(v[0]) else
z_WindowPos3svMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(var v: Int16) :=
z_WindowPos3svMESA_ovr_0(v);
private static procedure z_WindowPos3svMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos3svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(v: IntPtr) :=
z_WindowPos3svMESA_ovr_2(v);
private static procedure z_WindowPos4dMESA_ovr_0(x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glWindowPos4dMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dMESA(x: real; y: real; z: real; w: real) :=
z_WindowPos4dMESA_ovr_0(x, y, z, w);
private static procedure z_WindowPos4dvMESA_ovr_0(var v: real);
external 'opengl32.dll' name 'glWindowPos4dvMESA';
private static procedure z_WindowPos4dvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos4dvMESA_ovr_0(v[0]) else
z_WindowPos4dvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(var v: real) :=
z_WindowPos4dvMESA_ovr_0(v);
private static procedure z_WindowPos4dvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4dvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(v: IntPtr) :=
z_WindowPos4dvMESA_ovr_2(v);
private static procedure z_WindowPos4fMESA_ovr_0(x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glWindowPos4fMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fMESA(x: single; y: single; z: single; w: single) :=
z_WindowPos4fMESA_ovr_0(x, y, z, w);
private static procedure z_WindowPos4fvMESA_ovr_0(var v: single);
external 'opengl32.dll' name 'glWindowPos4fvMESA';
private static procedure z_WindowPos4fvMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos4fvMESA_ovr_0(v[0]) else
z_WindowPos4fvMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(var v: single) :=
z_WindowPos4fvMESA_ovr_0(v);
private static procedure z_WindowPos4fvMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4fvMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(v: IntPtr) :=
z_WindowPos4fvMESA_ovr_2(v);
private static procedure z_WindowPos4iMESA_ovr_0(x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glWindowPos4iMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4iMESA(x: Int32; y: Int32; z: Int32; w: Int32) :=
z_WindowPos4iMESA_ovr_0(x, y, z, w);
private static procedure z_WindowPos4ivMESA_ovr_0(var v: Int32);
external 'opengl32.dll' name 'glWindowPos4ivMESA';
private static procedure z_WindowPos4ivMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos4ivMESA_ovr_0(v[0]) else
z_WindowPos4ivMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(var v: Int32) :=
z_WindowPos4ivMESA_ovr_0(v);
private static procedure z_WindowPos4ivMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4ivMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(v: IntPtr) :=
z_WindowPos4ivMESA_ovr_2(v);
private static procedure z_WindowPos4sMESA_ovr_0(x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glWindowPos4sMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4sMESA(x: Int16; y: Int16; z: Int16; w: Int16) :=
z_WindowPos4sMESA_ovr_0(x, y, z, w);
private static procedure z_WindowPos4svMESA_ovr_0(var v: Int16);
external 'opengl32.dll' name 'glWindowPos4svMESA';
private static procedure z_WindowPos4svMESA_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_WindowPos4svMESA_ovr_0(v[0]) else
z_WindowPos4svMESA_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(var v: Int16) :=
z_WindowPos4svMESA_ovr_0(v);
private static procedure z_WindowPos4svMESA_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glWindowPos4svMESA';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(v: IntPtr) :=
z_WindowPos4svMESA_ovr_2(v);
end;
[PCUNotRestore]
glConditionalRenderNVX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginConditionalRenderNVX_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glBeginConditionalRenderNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRenderNVX(id: UInt32) :=
z_BeginConditionalRenderNVX_ovr_0(id);
private static procedure z_EndConditionalRenderNVX_ovr_0;
external 'opengl32.dll' name 'glEndConditionalRenderNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRenderNVX :=
z_EndConditionalRenderNVX_ovr_0;
end;
[PCUNotRestore]
glLinkedGpuMulticastNVX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_LGPUNamedBufferSubDataNVX_ovr_0(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glLGPUNamedBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LGPUNamedBufferSubDataNVX(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_LGPUNamedBufferSubDataNVX_ovr_0(gpuMask, buffer, offset, size, data);
private static procedure z_LGPUCopyImageSubDataNVX_ovr_0(sourceGpu: UInt32; destinationGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srxY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glLGPUCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LGPUCopyImageSubDataNVX(sourceGpu: UInt32; destinationGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srxY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32) :=
z_LGPUCopyImageSubDataNVX_ovr_0(sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
private static procedure z_LGPUInterlockNVX_ovr_0;
external 'opengl32.dll' name 'glLGPUInterlockNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LGPUInterlockNVX :=
z_LGPUInterlockNVX_ovr_0;
end;
[PCUNotRestore]
glAlphaToCoverageDitherControlNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_AlphaToCoverageDitherControlNV_ovr_0(mode: DummyEnum);
external 'opengl32.dll' name 'glAlphaToCoverageDitherControlNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaToCoverageDitherControlNV(mode: DummyEnum) :=
z_AlphaToCoverageDitherControlNV_ovr_0(mode);
end;
[PCUNotRestore]
glBindlessMultiDrawIndirectNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysIndirectBindlessNV_ovr_0(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysIndirectBindlessNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectBindlessNV(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32) :=
z_MultiDrawArraysIndirectBindlessNV_ovr_0(mode, indirect, drawCount, stride, vertexBufferCount);
private static procedure z_MultiDrawElementsIndirectBindlessNV_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsIndirectBindlessNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectBindlessNV(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32) :=
z_MultiDrawElementsIndirectBindlessNV_ovr_0(mode, &type, indirect, drawCount, stride, vertexBufferCount);
end;
[PCUNotRestore]
glBindlessMultiDrawIndirectCountNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiDrawArraysIndirectBindlessCountNV_ovr_0(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32);
external 'opengl32.dll' name 'glMultiDrawArraysIndirectBindlessCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectBindlessCountNV(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32) :=
z_MultiDrawArraysIndirectBindlessCountNV_ovr_0(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
private static procedure z_MultiDrawElementsIndirectBindlessCountNV_ovr_0(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32);
external 'opengl32.dll' name 'glMultiDrawElementsIndirectBindlessCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectBindlessCountNV(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32) :=
z_MultiDrawElementsIndirectBindlessCountNV_ovr_0(mode, &type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
end;
[PCUNotRestore]
glBindlessTextureNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetTextureHandleNV_ovr_0(texture: UInt32): UInt64;
external 'opengl32.dll' name 'glGetTextureHandleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureHandleNV(texture: UInt32): UInt64 :=
z_GetTextureHandleNV_ovr_0(texture);
private static function z_GetTextureSamplerHandleNV_ovr_0(texture: UInt32; sampler: UInt32): UInt64;
external 'opengl32.dll' name 'glGetTextureSamplerHandleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureSamplerHandleNV(texture: UInt32; sampler: UInt32): UInt64 :=
z_GetTextureSamplerHandleNV_ovr_0(texture, sampler);
private static procedure z_MakeTextureHandleResidentNV_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeTextureHandleResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleResidentNV(handle: UInt64) :=
z_MakeTextureHandleResidentNV_ovr_0(handle);
private static procedure z_MakeTextureHandleNonResidentNV_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeTextureHandleNonResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleNonResidentNV(handle: UInt64) :=
z_MakeTextureHandleNonResidentNV_ovr_0(handle);
private static function z_GetImageHandleNV_ovr_0(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64;
external 'opengl32.dll' name 'glGetImageHandleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetImageHandleNV(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64 :=
z_GetImageHandleNV_ovr_0(texture, level, layered, layer, format);
private static procedure z_MakeImageHandleResidentNV_ovr_0(handle: UInt64; access: DummyEnum);
external 'opengl32.dll' name 'glMakeImageHandleResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleResidentNV(handle: UInt64; access: DummyEnum) :=
z_MakeImageHandleResidentNV_ovr_0(handle, access);
private static procedure z_MakeImageHandleNonResidentNV_ovr_0(handle: UInt64);
external 'opengl32.dll' name 'glMakeImageHandleNonResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleNonResidentNV(handle: UInt64) :=
z_MakeImageHandleNonResidentNV_ovr_0(handle);
private static procedure z_UniformHandleui64NV_ovr_0(location: Int32; value: UInt64);
external 'opengl32.dll' name 'glUniformHandleui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64NV(location: Int32; value: UInt64) :=
z_UniformHandleui64NV_ovr_0(location, value);
private static procedure z_UniformHandleui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniformHandleui64vNV';
private static procedure z_UniformHandleui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformHandleui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_UniformHandleui64vNV_ovr_0(location, count, value[0]) else
z_UniformHandleui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_UniformHandleui64vNV_ovr_0(location, count, value);
private static procedure z_UniformHandleui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformHandleui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_UniformHandleui64vNV_ovr_2(location, count, value);
private static procedure z_ProgramUniformHandleui64NV_ovr_0(&program: UInt32; location: Int32; value: UInt64);
external 'opengl32.dll' name 'glProgramUniformHandleui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64NV(&program: UInt32; location: Int32; value: UInt64) :=
z_ProgramUniformHandleui64NV_ovr_0(&program, location, value);
private static procedure z_ProgramUniformHandleui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var values: UInt64);
external 'opengl32.dll' name 'glProgramUniformHandleui64vNV';
private static procedure z_ProgramUniformHandleui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
external 'opengl32.dll' name 'glProgramUniformHandleui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; values: array of UInt64) :=
if (values<>nil) and (values.Length<>0) then
z_ProgramUniformHandleui64vNV_ovr_0(&program, location, count, values[0]) else
z_ProgramUniformHandleui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; var values: UInt64) :=
z_ProgramUniformHandleui64vNV_ovr_0(&program, location, count, values);
private static procedure z_ProgramUniformHandleui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
external 'opengl32.dll' name 'glProgramUniformHandleui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; values: IntPtr) :=
z_ProgramUniformHandleui64vNV_ovr_2(&program, location, count, values);
private static function z_IsTextureHandleResidentNV_ovr_0(handle: UInt64): boolean;
external 'opengl32.dll' name 'glIsTextureHandleResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureHandleResidentNV(handle: UInt64): boolean :=
z_IsTextureHandleResidentNV_ovr_0(handle);
private static function z_IsImageHandleResidentNV_ovr_0(handle: UInt64): boolean;
external 'opengl32.dll' name 'glIsImageHandleResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsImageHandleResidentNV(handle: UInt64): boolean :=
z_IsImageHandleResidentNV_ovr_0(handle);
end;
[PCUNotRestore]
glBlendEquationAdvancedNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BlendParameteriNV_ovr_0(pname: DummyEnum; value: Int32);
external 'opengl32.dll' name 'glBlendParameteriNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendParameteriNV(pname: DummyEnum; value: Int32) :=
z_BlendParameteriNV_ovr_0(pname, value);
private static procedure z_BlendBarrierNV_ovr_0;
external 'opengl32.dll' name 'glBlendBarrierNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendBarrierNV :=
z_BlendBarrierNV_ovr_0;
end;
[PCUNotRestore]
glClipSpaceWScalingNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ViewportPositionWScaleNV_ovr_0(index: UInt32; xcoeff: single; ycoeff: single);
external 'opengl32.dll' name 'glViewportPositionWScaleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportPositionWScaleNV(index: UInt32; xcoeff: single; ycoeff: single) :=
z_ViewportPositionWScaleNV_ovr_0(index, xcoeff, ycoeff);
end;
[PCUNotRestore]
glCommandListNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CreateStatesNV_ovr_0(n: Int32; var states: UInt32);
external 'opengl32.dll' name 'glCreateStatesNV';
private static procedure z_CreateStatesNV_ovr_0_anh001(n: Int32; states: IntPtr);
external 'opengl32.dll' name 'glCreateStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; states: array of UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_CreateStatesNV_ovr_0(n, states[0]) else
z_CreateStatesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; var states: UInt32) :=
z_CreateStatesNV_ovr_0(n, states);
private static procedure z_CreateStatesNV_ovr_2(n: Int32; states: IntPtr);
external 'opengl32.dll' name 'glCreateStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; states: IntPtr) :=
z_CreateStatesNV_ovr_2(n, states);
private static procedure z_DeleteStatesNV_ovr_0(n: Int32; var states: UInt32);
external 'opengl32.dll' name 'glDeleteStatesNV';
private static procedure z_DeleteStatesNV_ovr_0_anh001(n: Int32; states: IntPtr);
external 'opengl32.dll' name 'glDeleteStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; states: array of UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DeleteStatesNV_ovr_0(n, states[0]) else
z_DeleteStatesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; var states: UInt32) :=
z_DeleteStatesNV_ovr_0(n, states);
private static procedure z_DeleteStatesNV_ovr_2(n: Int32; states: IntPtr);
external 'opengl32.dll' name 'glDeleteStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; states: IntPtr) :=
z_DeleteStatesNV_ovr_2(n, states);
private static function z_IsStateNV_ovr_0(state: UInt32): boolean;
external 'opengl32.dll' name 'glIsStateNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsStateNV(state: UInt32): boolean :=
z_IsStateNV_ovr_0(state);
private static procedure z_StateCaptureNV_ovr_0(state: UInt32; mode: DummyEnum);
external 'opengl32.dll' name 'glStateCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StateCaptureNV(state: UInt32; mode: DummyEnum) :=
z_StateCaptureNV_ovr_0(state, mode);
private static function z_GetCommandHeaderNV_ovr_0(tokenID: DummyEnum; size: UInt32): UInt32;
external 'opengl32.dll' name 'glGetCommandHeaderNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetCommandHeaderNV(tokenID: DummyEnum; size: UInt32): UInt32 :=
z_GetCommandHeaderNV_ovr_0(tokenID, size);
private static function z_GetStageIndexNV_ovr_0(_shadertype: ShaderType): UInt16;
external 'opengl32.dll' name 'glGetStageIndexNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetStageIndexNV(_shadertype: ShaderType): UInt16 :=
z_GetStageIndexNV_ovr_0(_shadertype);
private static procedure z_DrawCommandsNV_ovr_0(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
private static procedure z_DrawCommandsNV_ovr_0_anh000100(primitiveMode: DummyEnum; buffer: UInt32; indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
private static procedure z_DrawCommandsNV_ovr_0_anh000010(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
private static procedure z_DrawCommandsNV_ovr_0_anh000110(primitiveMode: DummyEnum; buffer: UInt32; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects[0], sizes[0], count) else
z_DrawCommandsNV_ovr_0_anh000010(primitiveMode, buffer, indirects[0], IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsNV_ovr_0_anh000100(primitiveMode, buffer, IntPtr.Zero, sizes[0], count) else
z_DrawCommandsNV_ovr_0_anh000110(primitiveMode, buffer, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsNV_ovr_1_anh000100(primitiveMode: DummyEnum; buffer: UInt32; indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects[0], sizes, count) else
z_DrawCommandsNV_ovr_0_anh000100(primitiveMode, buffer, IntPtr.Zero, sizes, count);
private static procedure z_DrawCommandsNV_ovr_2(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
private static procedure z_DrawCommandsNV_ovr_2_anh000100(primitiveMode: DummyEnum; buffer: UInt32; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsNV_ovr_2(primitiveMode, buffer, indirects[0], sizes, count) else
z_DrawCommandsNV_ovr_2_anh000100(primitiveMode, buffer, IntPtr.Zero, sizes, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects, sizes[0], count) else
z_DrawCommandsNV_ovr_0_anh000010(primitiveMode, buffer, indirects, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; var sizes: Int32; count: UInt32) :=
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects, sizes, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; count: UInt32) :=
z_DrawCommandsNV_ovr_2(primitiveMode, buffer, indirects, sizes, count);
private static procedure z_DrawCommandsNV_ovr_6(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
private static procedure z_DrawCommandsNV_ovr_6_anh000010(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: array of Int32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsNV_ovr_6(primitiveMode, buffer, indirects, sizes[0], count) else
z_DrawCommandsNV_ovr_6_anh000010(primitiveMode, buffer, indirects, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; var sizes: Int32; count: UInt32) :=
z_DrawCommandsNV_ovr_6(primitiveMode, buffer, indirects, sizes, count);
private static procedure z_DrawCommandsNV_ovr_8(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: IntPtr; count: UInt32) :=
z_DrawCommandsNV_ovr_8(primitiveMode, buffer, indirects, sizes, count);
private static procedure z_DrawCommandsAddressNV_ovr_0(primitiveMode: DummyEnum; var indirects: UInt64; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
private static procedure z_DrawCommandsAddressNV_ovr_0_anh00100(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
private static procedure z_DrawCommandsAddressNV_ovr_0_anh00010(primitiveMode: DummyEnum; var indirects: UInt64; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
private static procedure z_DrawCommandsAddressNV_ovr_0_anh00110(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; sizes: array of Int32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects[0], sizes[0], count) else
z_DrawCommandsAddressNV_ovr_0_anh00010(primitiveMode, indirects[0], IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsAddressNV_ovr_0_anh00100(primitiveMode, IntPtr.Zero, sizes[0], count) else
z_DrawCommandsAddressNV_ovr_0_anh00110(primitiveMode, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsAddressNV_ovr_1_anh00100(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; var sizes: Int32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects[0], sizes, count) else
z_DrawCommandsAddressNV_ovr_0_anh00100(primitiveMode, IntPtr.Zero, sizes, count);
private static procedure z_DrawCommandsAddressNV_ovr_2(primitiveMode: DummyEnum; var indirects: UInt64; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
private static procedure z_DrawCommandsAddressNV_ovr_2_anh00100(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; sizes: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsAddressNV_ovr_2(primitiveMode, indirects[0], sizes, count) else
z_DrawCommandsAddressNV_ovr_2_anh00100(primitiveMode, IntPtr.Zero, sizes, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; sizes: array of Int32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects, sizes[0], count) else
z_DrawCommandsAddressNV_ovr_0_anh00010(primitiveMode, indirects, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; var sizes: Int32; count: UInt32) :=
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects, sizes, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; sizes: IntPtr; count: UInt32) :=
z_DrawCommandsAddressNV_ovr_2(primitiveMode, indirects, sizes, count);
private static procedure z_DrawCommandsAddressNV_ovr_6(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
private static procedure z_DrawCommandsAddressNV_ovr_6_anh00010(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; sizes: array of Int32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsAddressNV_ovr_6(primitiveMode, indirects, sizes[0], count) else
z_DrawCommandsAddressNV_ovr_6_anh00010(primitiveMode, indirects, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32) :=
z_DrawCommandsAddressNV_ovr_6(primitiveMode, indirects, sizes, count);
private static procedure z_DrawCommandsAddressNV_ovr_8(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32) :=
z_DrawCommandsAddressNV_ovr_8(primitiveMode, indirects, sizes, count);
private static procedure z_DrawCommandsStatesNV_ovr_0(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0001100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0011100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0001010(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0011010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0000110(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0010110(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0001110(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_0_anh0011110(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects[0], sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects[0], sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000110(buffer, indirects[0], sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects[0], IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001010(buffer, indirects[0], IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001100(buffer, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001110(buffer, indirects[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010010(buffer, IntPtr.Zero, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010100(buffer, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010110(buffer, IntPtr.Zero, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0011010(buffer, IntPtr.Zero, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0011100(buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0011110(buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0000100(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0001100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_1_anh0011100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0001100(buffer, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0010100(buffer, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0011100(buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_2(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0000100(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0001100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_2_anh0011100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0000100(buffer, indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0001000(buffer, indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0001100(buffer, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0010000(buffer, IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0010100(buffer, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0011100(buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0001010(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_3_anh0011010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001010(buffer, indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010010(buffer, IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0011010(buffer, IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_4_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_4_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_4_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_5_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_5_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_5_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_6(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0000010(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0001010(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_6_anh0011010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0000010(buffer, indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0001010(buffer, indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0010010(buffer, IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0011010(buffer, IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_7_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_7_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_7_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_6_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_6_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_8(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_8_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_8_anh0001000(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_8_anh0011000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_8(buffer, indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_8_anh0001000(buffer, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_8_anh0010000(buffer, IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_8_anh0011000(buffer, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_9_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_9_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_9_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_9_anh0010110(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000110(buffer, indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010010(buffer, IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010110(buffer, IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_10_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_10_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_11_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_11_anh0010100(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_12_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_12_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0010010(buffer, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_13_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_14_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_15_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_15_anh0010010(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0000010(buffer, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0010010(buffer, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_16_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_6_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_17_anh0010000(buffer: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_8(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_8_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_18(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0000100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0010100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0000010(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0010010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0000110(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_18_anh0010110(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000010(buffer, indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000110(buffer, indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0010010(buffer, IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0010110(buffer, IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_19_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_19_anh0000100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_19_anh0010100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_18_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_18_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_20(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_20_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_20_anh0000100(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_20_anh0010100(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_20(buffer, indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_20_anh0000100(buffer, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_20_anh0010000(buffer, IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_20_anh0010100(buffer, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_21_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_21_anh0010010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000010(buffer, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0010010(buffer, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_22_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_18_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_23_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_20(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_20_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_24(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_24_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_24_anh0000010(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_24_anh0010010(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_24(buffer, indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_24_anh0000010(buffer, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_24_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_24_anh0010010(buffer, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_25_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_24(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_24_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_26(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_26_anh0010000(buffer: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesNV_ovr_26(buffer, indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesNV_ovr_26_anh0010000(buffer, IntPtr.Zero, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000110(buffer, indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001010(buffer, indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001110(buffer, indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0001010(buffer, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0000010(buffer, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0001010(buffer, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_6_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_8(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_8_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000110(buffer, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_0_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_2_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_0_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_6_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_8(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000010(buffer, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000110(buffer, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_18_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_20(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_20_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_18_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_20(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_24(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_24_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_24(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_26(buffer, indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_54(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0000100(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0001100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0000010(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0001010(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0000110(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_54_anh0001110(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000010(buffer, indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000110(buffer, indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0001010(buffer, indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0001110(buffer, indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_55_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_55_anh0000100(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_55_anh0001100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_54_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_54_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_56(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_56_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_56_anh0000100(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_56_anh0001100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_56_anh0000100(buffer, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_56_anh0001000(buffer, indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_56_anh0001100(buffer, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_57_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_57_anh0001010(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000010(buffer, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0001010(buffer, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_58_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_54_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_59_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_56_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_60(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_60_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_60_anh0000010(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_60_anh0001010(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_60_anh0000010(buffer, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_60_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_60_anh0001010(buffer, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_61_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_60_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_62(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_62_anh0001000(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesNV_ovr_62(buffer, indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesNV_ovr_62_anh0001000(buffer, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000010(buffer, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000110(buffer, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_54_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_56_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_54_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_60_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_62(buffer, indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_72(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_72_anh0000100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_72_anh0000010(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_72_anh0000110(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesNV_ovr_72_anh0000010(buffer, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_72_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_72_anh0000110(buffer, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesNV_ovr_73_anh0000100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_72_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_74(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_74_anh0000100(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesNV_ovr_74(buffer, indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesNV_ovr_74_anh0000100(buffer, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_72_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_74(buffer, indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_78(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
private static procedure z_DrawCommandsStatesNV_ovr_78_anh0000010(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesNV_ovr_78(buffer, indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesNV_ovr_78_anh0000010(buffer, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_78(buffer, indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesNV_ovr_80(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesNV_ovr_80(buffer, indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_0(var indirects: UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh000100(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh001100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh011100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh000010(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh010010(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh001010(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh011010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh000110(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh010110(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh001110(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_0_anh011110(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects[0], sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects[0], sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000110(indirects[0], sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects[0], IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001010(indirects[0], IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001100(indirects[0], IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001110(indirects[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010010(IntPtr.Zero, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010100(IntPtr.Zero, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010110(IntPtr.Zero, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh011010(IntPtr.Zero, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh011100(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh011110(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh000100(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh001100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_1_anh011100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001100(indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010100(IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh011100(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_2(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh000100(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh001100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_2_anh011100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh000100(indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh001000(indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh001100(indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh010000(IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh010100(IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh011000(IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh011100(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh010010(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh001010(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_3_anh011010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001010(indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010010(IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh011010(IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_4_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_4_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_4_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_5_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_5_anh001000(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_5_anh011000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh001000(indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh010000(IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_6(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh001000(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh011000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh000010(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh010010(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh001010(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_6_anh011010(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh000010(indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh001000(indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh001010(indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh010000(IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh010010(IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh011010(IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_7_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_7_anh001000(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_7_anh011000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh001000(indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh010000(IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_8(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_8_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_8_anh001000(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_8_anh011000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_8(indirects[0], sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_8_anh001000(indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_8_anh010000(IntPtr.Zero, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_8_anh011000(IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_9_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_9_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_9_anh010010(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_9_anh010110(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000110(indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010010(IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010110(IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_10_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_10_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_11_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_11_anh010100(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh000100(indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh010000(IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_12_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_12_anh010010(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010010(IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_13_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_14_anh010000(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_15_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_15_anh010010(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh000010(indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh010000(IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh010010(IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_16_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_17_anh010000(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_8(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_8_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_18(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh000100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh010100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh000010(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh010010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh000110(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_18_anh010110(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000010(indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh000100(indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000110(indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh010000(IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh010010(IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh010110(IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_19_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_19_anh000100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_19_anh010100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000100(indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh010000(IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_20(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_20_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_20_anh000100(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_20_anh010100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_20(indirects[0], sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_20_anh000100(indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_20_anh010000(IntPtr.Zero, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_20_anh010100(IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_21_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_21_anh010010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000010(indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh010000(IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh010010(IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_22_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_23_anh010000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_20(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_20_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_24(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_24_anh010000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_24_anh000010(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_24_anh010010(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_24(indirects[0], sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_24_anh000010(indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_24_anh010000(IntPtr.Zero, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_24_anh010010(IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_25_anh010000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_24(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_24_anh010000(IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_26(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_26_anh010000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_26(indirects[0], sizes, states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_26_anh010000(IntPtr.Zero, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000110(indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001010(indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001110(indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh000100(indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2_anh001000(indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001010(indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh001000(indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh001000(indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh000010(indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6_anh001000(indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh001010(indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh001000(indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_8(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_8_anh001000(indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000110(indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_2_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_0_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_6_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_8(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000010(indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18_anh000100(indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000110(indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_20(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_20_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_18_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_20(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_24(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_24_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_24(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_26(indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_54(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh000100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh001100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh000010(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh001010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh000110(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_54_anh001110(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000010(indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh000100(indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000110(indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh001000(indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh001010(indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh001110(indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_55_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_55_anh000100(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_55_anh001100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000100(indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh001000(indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_56(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_56_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_56_anh000100(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_56_anh001100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes[0], states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_56_anh000100(indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_56_anh001000(indirects, IntPtr.Zero, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_56_anh001100(indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_57_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_57_anh001010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000010(indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh001000(indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh001010(indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_58_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh001000(indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_59_anh001000(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_56_anh001000(indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_60(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_60_anh001000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_60_anh000010(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_60_anh001010(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes[0], states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_60_anh000010(indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_60_anh001000(indirects, IntPtr.Zero, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_60_anh001010(indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_61_anh001000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_60_anh001000(indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_62(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_62_anh001000(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_62(indirects, sizes[0], states, fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_62_anh001000(indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000010(indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54_anh000100(indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000110(indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_56_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_54_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_60_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_62(indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_72(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_72_anh000100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_72_anh000010(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_72_anh000110(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states[0], fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_72_anh000010(indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_72_anh000100(indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_72_anh000110(indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_73_anh000100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_72_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_74(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_74_anh000100(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_74(indirects, sizes, states[0], fbos, count) else
z_DrawCommandsStatesAddressNV_ovr_74_anh000100(indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_72_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_74(indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_78(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
private static procedure z_DrawCommandsStatesAddressNV_ovr_78_anh000010(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_DrawCommandsStatesAddressNV_ovr_78(indirects, sizes, states, fbos[0], count) else
z_DrawCommandsStatesAddressNV_ovr_78_anh000010(indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_78(indirects, sizes, states, fbos, count);
private static procedure z_DrawCommandsStatesAddressNV_ovr_80(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glDrawCommandsStatesAddressNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_DrawCommandsStatesAddressNV_ovr_80(indirects, sizes, states, fbos, count);
private static procedure z_CreateCommandListsNV_ovr_0(n: Int32; var lists: UInt32);
external 'opengl32.dll' name 'glCreateCommandListsNV';
private static procedure z_CreateCommandListsNV_ovr_0_anh001(n: Int32; lists: IntPtr);
external 'opengl32.dll' name 'glCreateCommandListsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; lists: array of UInt32) :=
if (lists<>nil) and (lists.Length<>0) then
z_CreateCommandListsNV_ovr_0(n, lists[0]) else
z_CreateCommandListsNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; var lists: UInt32) :=
z_CreateCommandListsNV_ovr_0(n, lists);
private static procedure z_CreateCommandListsNV_ovr_2(n: Int32; lists: IntPtr);
external 'opengl32.dll' name 'glCreateCommandListsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; lists: IntPtr) :=
z_CreateCommandListsNV_ovr_2(n, lists);
private static procedure z_DeleteCommandListsNV_ovr_0(n: Int32; var lists: UInt32);
external 'opengl32.dll' name 'glDeleteCommandListsNV';
private static procedure z_DeleteCommandListsNV_ovr_0_anh001(n: Int32; lists: IntPtr);
external 'opengl32.dll' name 'glDeleteCommandListsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; lists: array of UInt32) :=
if (lists<>nil) and (lists.Length<>0) then
z_DeleteCommandListsNV_ovr_0(n, lists[0]) else
z_DeleteCommandListsNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; var lists: UInt32) :=
z_DeleteCommandListsNV_ovr_0(n, lists);
private static procedure z_DeleteCommandListsNV_ovr_2(n: Int32; lists: IntPtr);
external 'opengl32.dll' name 'glDeleteCommandListsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; lists: IntPtr) :=
z_DeleteCommandListsNV_ovr_2(n, lists);
private static function z_IsCommandListNV_ovr_0(list: UInt32): boolean;
external 'opengl32.dll' name 'glIsCommandListNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsCommandListNV(list: UInt32): boolean :=
z_IsCommandListNV_ovr_0(list);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00001100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00011100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00001010(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00011010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00000110(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00010110(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00001110(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_0_anh00011110(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects[0], sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects[0], sizes[0], IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000110(list, segment, indirects[0], sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects[0], IntPtr.Zero, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001010(list, segment, indirects[0], IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001100(list, segment, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001110(list, segment, indirects[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes[0], states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010010(list, segment, IntPtr.Zero, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010100(list, segment, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010110(list, segment, IntPtr.Zero, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011010(list, segment, IntPtr.Zero, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011100(list, segment, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011110(list, segment, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00001100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_1_anh00011100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001100(list, segment, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010100(list, segment, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011100(list, segment, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00001100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_2_anh00011100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00000100(list, segment, indirects[0], sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001000(list, segment, indirects[0], IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001100(list, segment, indirects[0], IntPtr.Zero, IntPtr.Zero, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010000(list, segment, IntPtr.Zero, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010100(list, segment, IntPtr.Zero, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00011100(list, segment, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00001010(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_3_anh00011010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001010(list, segment, indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010010(list, segment, IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011010(list, segment, IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_4_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_4_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_4_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_5_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_5_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_5_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00000010(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00001010(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_6_anh00011010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00000010(list, segment, indirects[0], sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001010(list, segment, indirects[0], IntPtr.Zero, states, IntPtr.Zero, count) else
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010010(list, segment, IntPtr.Zero, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00011010(list, segment, IntPtr.Zero, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_7_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_7_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_7_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_8(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_8_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_8_anh00001000(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_8_anh00011000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects[0], sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_8_anh00001000(list, segment, indirects[0], IntPtr.Zero, states, fbos, count) else
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_8_anh00010000(list, segment, IntPtr.Zero, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_8_anh00011000(list, segment, IntPtr.Zero, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_9_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_9_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_9_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_9_anh00010110(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000110(list, segment, indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010010(list, segment, IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010110(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_10_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_10_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_11_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_11_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_12_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_12_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010010(list, segment, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_13_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_14_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_15_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_15_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00000010(list, segment, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010010(list, segment, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_16_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_17_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_8_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00000010(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00000110(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_18_anh00010110(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000010(list, segment, indirects[0], sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000110(list, segment, indirects[0], sizes, IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010010(list, segment, IntPtr.Zero, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010110(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_19_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_19_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_19_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_20(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_20_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_20_anh00000100(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_20_anh00010100(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects[0], sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_20_anh00000100(list, segment, indirects[0], sizes, IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_20_anh00010000(list, segment, IntPtr.Zero, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_20_anh00010100(list, segment, IntPtr.Zero, sizes, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_21_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_21_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000010(list, segment, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010010(list, segment, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_22_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_23_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_20_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_24(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_24_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_24_anh00000010(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_24_anh00010010(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects[0], sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_24_anh00000010(list, segment, indirects[0], sizes, states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_24_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_24_anh00010010(list, segment, IntPtr.Zero, sizes, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_25_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_24_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_26(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_26_anh00010000(list: UInt32; segment: UInt32; indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (indirects<>nil) and (indirects.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_26(list, segment, indirects[0], sizes, states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_26_anh00010000(list, segment, IntPtr.Zero, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000110(list, segment, indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001010(list, segment, indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001110(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001010(list, segment, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00000010(list, segment, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001010(list, segment, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_8_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000110(list, segment, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_2_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_0_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_6_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000010(list, segment, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000110(list, segment, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_20_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_18_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_24_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_26(list, segment, indirects, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00001100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00000010(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00001010(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00000110(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_54_anh00001110(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000010(list, segment, indirects, sizes[0], states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000110(list, segment, indirects, sizes[0], IntPtr.Zero, IntPtr.Zero, count) else
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001010(list, segment, indirects, IntPtr.Zero, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001110(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_55_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_55_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_55_anh00001100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_56(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_56_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_56_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_56_anh00001100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes[0], states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_56_anh00000100(list, segment, indirects, sizes[0], IntPtr.Zero, fbos, count) else
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_56_anh00001000(list, segment, indirects, IntPtr.Zero, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_56_anh00001100(list, segment, indirects, IntPtr.Zero, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_57_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_57_anh00001010(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000010(list, segment, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001010(list, segment, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_58_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_59_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_56_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_60(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_60_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_60_anh00000010(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_60_anh00001010(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes[0], states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_60_anh00000010(list, segment, indirects, sizes[0], states, IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_60_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_60_anh00001010(list, segment, indirects, IntPtr.Zero, states, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_61_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_60_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_62(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_62_anh00001000(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
if (sizes<>nil) and (sizes.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_62(list, segment, indirects, sizes[0], states, fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_62_anh00001000(list, segment, indirects, IntPtr.Zero, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000010(list, segment, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000110(list, segment, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_56_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_54_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_60_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_62(list, segment, indirects, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_72(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_72_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_72_anh00000010(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_72_anh00000110(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states[0], fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_72_anh00000010(list, segment, indirects, sizes, states[0], IntPtr.Zero, count) else
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_72_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_72_anh00000110(list, segment, indirects, sizes, IntPtr.Zero, IntPtr.Zero, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_73_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_72_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_74(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_74_anh00000100(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32) :=
if (states<>nil) and (states.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_74(list, segment, indirects, sizes, states[0], fbos, count) else
z_ListDrawCommandsStatesClientNV_ovr_74_anh00000100(list, segment, indirects, sizes, IntPtr.Zero, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_72_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states, fbos, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_74(list, segment, indirects, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_78(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
private static procedure z_ListDrawCommandsStatesClientNV_ovr_78_anh00000010(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32) :=
if (fbos<>nil) and (fbos.Length<>0) then
z_ListDrawCommandsStatesClientNV_ovr_78(list, segment, indirects, sizes, states, fbos[0], count) else
z_ListDrawCommandsStatesClientNV_ovr_78_anh00000010(list, segment, indirects, sizes, states, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_78(list, segment, indirects, sizes, states, fbos, count);
private static procedure z_ListDrawCommandsStatesClientNV_ovr_80(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
external 'opengl32.dll' name 'glListDrawCommandsStatesClientNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32) :=
z_ListDrawCommandsStatesClientNV_ovr_80(list, segment, indirects, sizes, states, fbos, count);
private static procedure z_CommandListSegmentsNV_ovr_0(list: UInt32; segments: UInt32);
external 'opengl32.dll' name 'glCommandListSegmentsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CommandListSegmentsNV(list: UInt32; segments: UInt32) :=
z_CommandListSegmentsNV_ovr_0(list, segments);
private static procedure z_CompileCommandListNV_ovr_0(list: UInt32);
external 'opengl32.dll' name 'glCompileCommandListNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileCommandListNV(list: UInt32) :=
z_CompileCommandListNV_ovr_0(list);
private static procedure z_CallCommandListNV_ovr_0(list: UInt32);
external 'opengl32.dll' name 'glCallCommandListNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallCommandListNV(list: UInt32) :=
z_CallCommandListNV_ovr_0(list);
end;
[PCUNotRestore]
glConditionalRenderNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginConditionalRenderNV_ovr_0(id: UInt32; mode: ConditionalRenderMode);
external 'opengl32.dll' name 'glBeginConditionalRenderNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRenderNV(id: UInt32; mode: ConditionalRenderMode) :=
z_BeginConditionalRenderNV_ovr_0(id, mode);
private static procedure z_EndConditionalRenderNV_ovr_0;
external 'opengl32.dll' name 'glEndConditionalRenderNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRenderNV :=
z_EndConditionalRenderNV_ovr_0;
end;
[PCUNotRestore]
glConservativeRasterNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SubpixelPrecisionBiasNV_ovr_0(xbits: UInt32; ybits: UInt32);
external 'opengl32.dll' name 'glSubpixelPrecisionBiasNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SubpixelPrecisionBiasNV(xbits: UInt32; ybits: UInt32) :=
z_SubpixelPrecisionBiasNV_ovr_0(xbits, ybits);
end;
[PCUNotRestore]
glConservativeRasterDilateNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ConservativeRasterParameterfNV_ovr_0(pname: DummyEnum; value: single);
external 'opengl32.dll' name 'glConservativeRasterParameterfNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConservativeRasterParameterfNV(pname: DummyEnum; value: single) :=
z_ConservativeRasterParameterfNV_ovr_0(pname, value);
end;
[PCUNotRestore]
glConservativeRasterPreSnapTrianglesNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ConservativeRasterParameteriNV_ovr_0(pname: DummyEnum; param: Int32);
external 'opengl32.dll' name 'glConservativeRasterParameteriNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConservativeRasterParameteriNV(pname: DummyEnum; param: Int32) :=
z_ConservativeRasterParameteriNV_ovr_0(pname, param);
end;
[PCUNotRestore]
glCopyImageNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CopyImageSubDataNV_ovr_0(srcName: UInt32; srcTarget: CopyBufferSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyBufferSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32);
external 'opengl32.dll' name 'glCopyImageSubDataNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyImageSubDataNV(srcName: UInt32; srcTarget: CopyBufferSubDataTarget; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: CopyBufferSubDataTarget; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32) :=
z_CopyImageSubDataNV_ovr_0(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
end;
[PCUNotRestore]
glDepthBufferFloatNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DepthRangedNV_ovr_0(zNear: real; zFar: real);
external 'opengl32.dll' name 'glDepthRangedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangedNV(zNear: real; zFar: real) :=
z_DepthRangedNV_ovr_0(zNear, zFar);
private static procedure z_ClearDepthdNV_ovr_0(depth: real);
external 'opengl32.dll' name 'glClearDepthdNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthdNV(depth: real) :=
z_ClearDepthdNV_ovr_0(depth);
private static procedure z_DepthBoundsdNV_ovr_0(zmin: real; zmax: real);
external 'opengl32.dll' name 'glDepthBoundsdNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthBoundsdNV(zmin: real; zmax: real) :=
z_DepthBoundsdNV_ovr_0(zmin, zmax);
end;
[PCUNotRestore]
glDrawTextureNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawTextureNV_ovr_0(texture: UInt32; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single);
external 'opengl32.dll' name 'glDrawTextureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTextureNV(texture: UInt32; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single) :=
z_DrawTextureNV_ovr_0(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
end;
[PCUNotRestore]
glDrawVulkanImageNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawVkImageNV_ovr_0(vkImage: UInt64; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single);
external 'opengl32.dll' name 'glDrawVkImageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawVkImageNV(vkImage: UInt64; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single) :=
z_DrawVkImageNV_ovr_0(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
private static function z_GetVkProcAddrNV_ovr_0(name: IntPtr): GLVULKANPROCNV;
external 'opengl32.dll' name 'glGetVkProcAddrNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetVkProcAddrNV(name: string): GLVULKANPROCNV;
begin
var par_1_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetVkProcAddrNV_ovr_0(par_1_str_ptr);
Marshal.FreeHGlobal(par_1_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetVkProcAddrNV(name: IntPtr): GLVULKANPROCNV :=
z_GetVkProcAddrNV_ovr_0(name);
private static procedure z_WaitVkSemaphoreNV_ovr_0(vkSemaphore: UInt64);
external 'opengl32.dll' name 'glWaitVkSemaphoreNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitVkSemaphoreNV(vkSemaphore: UInt64) :=
z_WaitVkSemaphoreNV_ovr_0(vkSemaphore);
private static procedure z_SignalVkSemaphoreNV_ovr_0(vkSemaphore: UInt64);
external 'opengl32.dll' name 'glSignalVkSemaphoreNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalVkSemaphoreNV(vkSemaphore: UInt64) :=
z_SignalVkSemaphoreNV_ovr_0(vkSemaphore);
private static procedure z_SignalVkFenceNV_ovr_0(vkFence: UInt64);
external 'opengl32.dll' name 'glSignalVkFenceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalVkFenceNV(vkFence: UInt64) :=
z_SignalVkFenceNV_ovr_0(vkFence);
end;
[PCUNotRestore]
glEvaluatorsNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MapControlPointsNV_ovr_0(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; uorder: Int32; vorder: Int32; &packed: boolean; points: IntPtr);
external 'opengl32.dll' name 'glMapControlPointsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapControlPointsNV(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; uorder: Int32; vorder: Int32; &packed: boolean; points: IntPtr) :=
z_MapControlPointsNV_ovr_0(target, index, &type, ustride, vstride, uorder, vorder, &packed, points);
private static procedure z_MapParameterivNV_ovr_0(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glMapParameterivNV';
private static procedure z_MapParameterivNV_ovr_0_anh0001(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMapParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MapParameterivNV_ovr_0(target, pname, ¶ms[0]) else
z_MapParameterivNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32) :=
z_MapParameterivNV_ovr_0(target, pname, ¶ms);
private static procedure z_MapParameterivNV_ovr_2(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMapParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr) :=
z_MapParameterivNV_ovr_2(target, pname, ¶ms);
private static procedure z_MapParameterfvNV_ovr_0(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glMapParameterfvNV';
private static procedure z_MapParameterfvNV_ovr_0_anh0001(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMapParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MapParameterfvNV_ovr_0(target, pname, ¶ms[0]) else
z_MapParameterfvNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single) :=
z_MapParameterfvNV_ovr_0(target, pname, ¶ms);
private static procedure z_MapParameterfvNV_ovr_2(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMapParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr) :=
z_MapParameterfvNV_ovr_2(target, pname, ¶ms);
private static procedure z_GetMapControlPointsNV_ovr_0(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; &packed: boolean; points: IntPtr);
external 'opengl32.dll' name 'glGetMapControlPointsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapControlPointsNV(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; &packed: boolean; points: IntPtr) :=
z_GetMapControlPointsNV_ovr_0(target, index, &type, ustride, vstride, &packed, points);
private static procedure z_GetMapParameterivNV_ovr_0(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMapParameterivNV';
private static procedure z_GetMapParameterivNV_ovr_0_anh0001(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMapParameterivNV_ovr_0(target, pname, ¶ms[0]) else
z_GetMapParameterivNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32) :=
z_GetMapParameterivNV_ovr_0(target, pname, ¶ms);
private static procedure z_GetMapParameterivNV_ovr_2(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr) :=
z_GetMapParameterivNV_ovr_2(target, pname, ¶ms);
private static procedure z_GetMapParameterfvNV_ovr_0(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetMapParameterfvNV';
private static procedure z_GetMapParameterfvNV_ovr_0_anh0001(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMapParameterfvNV_ovr_0(target, pname, ¶ms[0]) else
z_GetMapParameterfvNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single) :=
z_GetMapParameterfvNV_ovr_0(target, pname, ¶ms);
private static procedure z_GetMapParameterfvNV_ovr_2(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr) :=
z_GetMapParameterfvNV_ovr_2(target, pname, ¶ms);
private static procedure z_GetMapAttribParameterivNV_ovr_0(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMapAttribParameterivNV';
private static procedure z_GetMapAttribParameterivNV_ovr_0_anh00001(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapAttribParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMapAttribParameterivNV_ovr_0(target, index, pname, ¶ms[0]) else
z_GetMapAttribParameterivNV_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: Int32) :=
z_GetMapAttribParameterivNV_ovr_0(target, index, pname, ¶ms);
private static procedure z_GetMapAttribParameterivNV_ovr_2(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapAttribParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr) :=
z_GetMapAttribParameterivNV_ovr_2(target, index, pname, ¶ms);
private static procedure z_GetMapAttribParameterfvNV_ovr_0(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetMapAttribParameterfvNV';
private static procedure z_GetMapAttribParameterfvNV_ovr_0_anh00001(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapAttribParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMapAttribParameterfvNV_ovr_0(target, index, pname, ¶ms[0]) else
z_GetMapAttribParameterfvNV_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: single) :=
z_GetMapAttribParameterfvNV_ovr_0(target, index, pname, ¶ms);
private static procedure z_GetMapAttribParameterfvNV_ovr_2(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMapAttribParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr) :=
z_GetMapAttribParameterfvNV_ovr_2(target, index, pname, ¶ms);
private static procedure z_EvalMapsNV_ovr_0(target: EvalTargetNV; mode: EvalMapsModeNV);
external 'opengl32.dll' name 'glEvalMapsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMapsNV(target: EvalTargetNV; mode: EvalMapsModeNV) :=
z_EvalMapsNV_ovr_0(target, mode);
end;
[PCUNotRestore]
glExplicitMultisampleNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetMultisamplefvNV_ovr_0(pname: GetMultisamplePNameNV; index: UInt32; var val: single);
external 'opengl32.dll' name 'glGetMultisamplefvNV';
private static procedure z_GetMultisamplefvNV_ovr_0_anh0001(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glGetMultisamplefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; val: array of single) :=
if (val<>nil) and (val.Length<>0) then
z_GetMultisamplefvNV_ovr_0(pname, index, val[0]) else
z_GetMultisamplefvNV_ovr_0_anh0001(pname, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; var val: single) :=
z_GetMultisamplefvNV_ovr_0(pname, index, val);
private static procedure z_GetMultisamplefvNV_ovr_2(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr);
external 'opengl32.dll' name 'glGetMultisamplefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr) :=
z_GetMultisamplefvNV_ovr_2(pname, index, val);
private static procedure z_SampleMaskIndexedNV_ovr_0(index: UInt32; mask: DummyFlags);
external 'opengl32.dll' name 'glSampleMaskIndexedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskIndexedNV(index: UInt32; mask: DummyFlags) :=
z_SampleMaskIndexedNV_ovr_0(index, mask);
private static procedure z_TexRenderbufferNV_ovr_0(target: TextureTarget; renderbuffer: UInt32);
external 'opengl32.dll' name 'glTexRenderbufferNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexRenderbufferNV(target: TextureTarget; renderbuffer: UInt32) :=
z_TexRenderbufferNV_ovr_0(target, renderbuffer);
end;
[PCUNotRestore]
glFenceNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DeleteFencesNV_ovr_0(n: Int32; var fences: UInt32);
external 'opengl32.dll' name 'glDeleteFencesNV';
private static procedure z_DeleteFencesNV_ovr_0_anh001(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glDeleteFencesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; fences: array of UInt32) :=
if (fences<>nil) and (fences.Length<>0) then
z_DeleteFencesNV_ovr_0(n, fences[0]) else
z_DeleteFencesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; var fences: UInt32) :=
z_DeleteFencesNV_ovr_0(n, fences);
private static procedure z_DeleteFencesNV_ovr_2(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glDeleteFencesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; fences: IntPtr) :=
z_DeleteFencesNV_ovr_2(n, fences);
private static procedure z_GenFencesNV_ovr_0(n: Int32; var fences: UInt32);
external 'opengl32.dll' name 'glGenFencesNV';
private static procedure z_GenFencesNV_ovr_0_anh001(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glGenFencesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; fences: array of UInt32) :=
if (fences<>nil) and (fences.Length<>0) then
z_GenFencesNV_ovr_0(n, fences[0]) else
z_GenFencesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; var fences: UInt32) :=
z_GenFencesNV_ovr_0(n, fences);
private static procedure z_GenFencesNV_ovr_2(n: Int32; fences: IntPtr);
external 'opengl32.dll' name 'glGenFencesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; fences: IntPtr) :=
z_GenFencesNV_ovr_2(n, fences);
private static function z_IsFenceNV_ovr_0(fence: UInt32): boolean;
external 'opengl32.dll' name 'glIsFenceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFenceNV(fence: UInt32): boolean :=
z_IsFenceNV_ovr_0(fence);
private static function z_TestFenceNV_ovr_0(fence: UInt32): boolean;
external 'opengl32.dll' name 'glTestFenceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestFenceNV(fence: UInt32): boolean :=
z_TestFenceNV_ovr_0(fence);
private static procedure z_GetFenceivNV_ovr_0(fence: UInt32; pname: FenceParameterNameNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFenceivNV';
private static procedure z_GetFenceivNV_ovr_0_anh0001(fence: UInt32; pname: FenceParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFenceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFenceivNV_ovr_0(fence, pname, ¶ms[0]) else
z_GetFenceivNV_ovr_0_anh0001(fence, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; var ¶ms: Int32) :=
z_GetFenceivNV_ovr_0(fence, pname, ¶ms);
private static procedure z_GetFenceivNV_ovr_2(fence: UInt32; pname: FenceParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFenceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; ¶ms: IntPtr) :=
z_GetFenceivNV_ovr_2(fence, pname, ¶ms);
private static procedure z_FinishFenceNV_ovr_0(fence: UInt32);
external 'opengl32.dll' name 'glFinishFenceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishFenceNV(fence: UInt32) :=
z_FinishFenceNV_ovr_0(fence);
private static procedure z_SetFenceNV_ovr_0(fence: UInt32; condition: FenceConditionNV);
external 'opengl32.dll' name 'glSetFenceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFenceNV(fence: UInt32; condition: FenceConditionNV) :=
z_SetFenceNV_ovr_0(fence, condition);
end;
[PCUNotRestore]
glFragmentCoverageToColorNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FragmentCoverageColorNV_ovr_0(color: UInt32);
external 'opengl32.dll' name 'glFragmentCoverageColorNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentCoverageColorNV(color: UInt32) :=
z_FragmentCoverageColorNV_ovr_0(color);
end;
[PCUNotRestore]
glFragmentProgramNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramNamedParameter4fNV_ovr_0(id: UInt32; len: Int32; var name: Byte; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fNV';
private static procedure z_ProgramNamedParameter4fNV_ovr_0_anh00010000(id: UInt32; len: Int32; name: IntPtr; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; name: array of Byte; x: single; y: single; z: single; w: single) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4fNV_ovr_0(id, len, name[0], x, y, z, w) else
z_ProgramNamedParameter4fNV_ovr_0_anh00010000(id, len, IntPtr.Zero, x, y, z, w);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; var name: Byte; x: single; y: single; z: single; w: single) :=
z_ProgramNamedParameter4fNV_ovr_0(id, len, name, x, y, z, w);
private static procedure z_ProgramNamedParameter4fNV_ovr_2(id: UInt32; len: Int32; name: IntPtr; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; name: IntPtr; x: single; y: single; z: single; w: single) :=
z_ProgramNamedParameter4fNV_ovr_2(id, len, name, x, y, z, w);
private static procedure z_ProgramNamedParameter4fvNV_ovr_0(id: UInt32; len: Int32; var name: Byte; var v: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
private static procedure z_ProgramNamedParameter4fvNV_ovr_0_anh00010(id: UInt32; len: Int32; name: IntPtr; var v: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
private static procedure z_ProgramNamedParameter4fvNV_ovr_0_anh00001(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
private static procedure z_ProgramNamedParameter4fvNV_ovr_0_anh00011(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; v: array of single) :=
if (name<>nil) and (name.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name[0], v[0]) else
z_ProgramNamedParameter4fvNV_ovr_0_anh00001(id, len, name[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_0_anh00010(id, len, IntPtr.Zero, v[0]) else
z_ProgramNamedParameter4fvNV_ovr_0_anh00011(id, len, IntPtr.Zero, IntPtr.Zero);
private static procedure z_ProgramNamedParameter4fvNV_ovr_1_anh00010(id: UInt32; len: Int32; name: IntPtr; var v: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; var v: single) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name[0], v) else
z_ProgramNamedParameter4fvNV_ovr_0_anh00010(id, len, IntPtr.Zero, v);
private static procedure z_ProgramNamedParameter4fvNV_ovr_2(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
private static procedure z_ProgramNamedParameter4fvNV_ovr_2_anh00010(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; v: IntPtr) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_2(id, len, name[0], v) else
z_ProgramNamedParameter4fvNV_ovr_2_anh00010(id, len, IntPtr.Zero, v);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name, v[0]) else
z_ProgramNamedParameter4fvNV_ovr_0_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; var v: single) :=
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name, v);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; v: IntPtr) :=
z_ProgramNamedParameter4fvNV_ovr_2(id, len, name, v);
private static procedure z_ProgramNamedParameter4fvNV_ovr_6(id: UInt32; len: Int32; name: IntPtr; var v: single);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
private static procedure z_ProgramNamedParameter4fvNV_ovr_6_anh00001(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4fvNV_ovr_6(id, len, name, v[0]) else
z_ProgramNamedParameter4fvNV_ovr_6_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; var v: single) :=
z_ProgramNamedParameter4fvNV_ovr_6(id, len, name, v);
private static procedure z_ProgramNamedParameter4fvNV_ovr_8(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; v: IntPtr) :=
z_ProgramNamedParameter4fvNV_ovr_8(id, len, name, v);
private static procedure z_ProgramNamedParameter4dNV_ovr_0(id: UInt32; len: Int32; var name: Byte; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dNV';
private static procedure z_ProgramNamedParameter4dNV_ovr_0_anh00010000(id: UInt32; len: Int32; name: IntPtr; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; name: array of Byte; x: real; y: real; z: real; w: real) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4dNV_ovr_0(id, len, name[0], x, y, z, w) else
z_ProgramNamedParameter4dNV_ovr_0_anh00010000(id, len, IntPtr.Zero, x, y, z, w);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; var name: Byte; x: real; y: real; z: real; w: real) :=
z_ProgramNamedParameter4dNV_ovr_0(id, len, name, x, y, z, w);
private static procedure z_ProgramNamedParameter4dNV_ovr_2(id: UInt32; len: Int32; name: IntPtr; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; name: IntPtr; x: real; y: real; z: real; w: real) :=
z_ProgramNamedParameter4dNV_ovr_2(id, len, name, x, y, z, w);
private static procedure z_ProgramNamedParameter4dvNV_ovr_0(id: UInt32; len: Int32; var name: Byte; var v: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
private static procedure z_ProgramNamedParameter4dvNV_ovr_0_anh00010(id: UInt32; len: Int32; name: IntPtr; var v: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
private static procedure z_ProgramNamedParameter4dvNV_ovr_0_anh00001(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
private static procedure z_ProgramNamedParameter4dvNV_ovr_0_anh00011(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; v: array of real) :=
if (name<>nil) and (name.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name[0], v[0]) else
z_ProgramNamedParameter4dvNV_ovr_0_anh00001(id, len, name[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_0_anh00010(id, len, IntPtr.Zero, v[0]) else
z_ProgramNamedParameter4dvNV_ovr_0_anh00011(id, len, IntPtr.Zero, IntPtr.Zero);
private static procedure z_ProgramNamedParameter4dvNV_ovr_1_anh00010(id: UInt32; len: Int32; name: IntPtr; var v: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; var v: real) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name[0], v) else
z_ProgramNamedParameter4dvNV_ovr_0_anh00010(id, len, IntPtr.Zero, v);
private static procedure z_ProgramNamedParameter4dvNV_ovr_2(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
private static procedure z_ProgramNamedParameter4dvNV_ovr_2_anh00010(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; v: IntPtr) :=
if (name<>nil) and (name.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_2(id, len, name[0], v) else
z_ProgramNamedParameter4dvNV_ovr_2_anh00010(id, len, IntPtr.Zero, v);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name, v[0]) else
z_ProgramNamedParameter4dvNV_ovr_0_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; var v: real) :=
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name, v);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; v: IntPtr) :=
z_ProgramNamedParameter4dvNV_ovr_2(id, len, name, v);
private static procedure z_ProgramNamedParameter4dvNV_ovr_6(id: UInt32; len: Int32; name: IntPtr; var v: real);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
private static procedure z_ProgramNamedParameter4dvNV_ovr_6_anh00001(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramNamedParameter4dvNV_ovr_6(id, len, name, v[0]) else
z_ProgramNamedParameter4dvNV_ovr_6_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; var v: real) :=
z_ProgramNamedParameter4dvNV_ovr_6(id, len, name, v);
private static procedure z_ProgramNamedParameter4dvNV_ovr_8(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glProgramNamedParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; v: IntPtr) :=
z_ProgramNamedParameter4dvNV_ovr_8(id, len, name, v);
private static procedure z_GetProgramNamedParameterfvNV_ovr_0(id: UInt32; len: Int32; var name: Byte; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
private static procedure z_GetProgramNamedParameterfvNV_ovr_0_anh00010(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
private static procedure z_GetProgramNamedParameterfvNV_ovr_0_anh00001(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
private static procedure z_GetProgramNamedParameterfvNV_ovr_0_anh00011(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: array of single) :=
if (name<>nil) and (name.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name[0], ¶ms[0]) else
z_GetProgramNamedParameterfvNV_ovr_0_anh00001(id, len, name[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_0_anh00010(id, len, IntPtr.Zero, ¶ms[0]) else
z_GetProgramNamedParameterfvNV_ovr_0_anh00011(id, len, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramNamedParameterfvNV_ovr_1_anh00010(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; var ¶ms: single) :=
if (name<>nil) and (name.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name[0], ¶ms) else
z_GetProgramNamedParameterfvNV_ovr_0_anh00010(id, len, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramNamedParameterfvNV_ovr_2(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
private static procedure z_GetProgramNamedParameterfvNV_ovr_2_anh00010(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: IntPtr) :=
if (name<>nil) and (name.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_2(id, len, name[0], ¶ms) else
z_GetProgramNamedParameterfvNV_ovr_2_anh00010(id, len, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name, ¶ms[0]) else
z_GetProgramNamedParameterfvNV_ovr_0_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; var ¶ms: single) :=
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr) :=
z_GetProgramNamedParameterfvNV_ovr_2(id, len, name, ¶ms);
private static procedure z_GetProgramNamedParameterfvNV_ovr_6(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
private static procedure z_GetProgramNamedParameterfvNV_ovr_6_anh00001(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterfvNV_ovr_6(id, len, name, ¶ms[0]) else
z_GetProgramNamedParameterfvNV_ovr_6_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single) :=
z_GetProgramNamedParameterfvNV_ovr_6(id, len, name, ¶ms);
private static procedure z_GetProgramNamedParameterfvNV_ovr_8(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr) :=
z_GetProgramNamedParameterfvNV_ovr_8(id, len, name, ¶ms);
private static procedure z_GetProgramNamedParameterdvNV_ovr_0(id: UInt32; len: Int32; var name: Byte; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
private static procedure z_GetProgramNamedParameterdvNV_ovr_0_anh00010(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
private static procedure z_GetProgramNamedParameterdvNV_ovr_0_anh00001(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
private static procedure z_GetProgramNamedParameterdvNV_ovr_0_anh00011(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: array of real) :=
if (name<>nil) and (name.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name[0], ¶ms[0]) else
z_GetProgramNamedParameterdvNV_ovr_0_anh00001(id, len, name[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_0_anh00010(id, len, IntPtr.Zero, ¶ms[0]) else
z_GetProgramNamedParameterdvNV_ovr_0_anh00011(id, len, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramNamedParameterdvNV_ovr_1_anh00010(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; var ¶ms: real) :=
if (name<>nil) and (name.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name[0], ¶ms) else
z_GetProgramNamedParameterdvNV_ovr_0_anh00010(id, len, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramNamedParameterdvNV_ovr_2(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
private static procedure z_GetProgramNamedParameterdvNV_ovr_2_anh00010(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: IntPtr) :=
if (name<>nil) and (name.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_2(id, len, name[0], ¶ms) else
z_GetProgramNamedParameterdvNV_ovr_2_anh00010(id, len, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name, ¶ms[0]) else
z_GetProgramNamedParameterdvNV_ovr_0_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; var ¶ms: real) :=
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr) :=
z_GetProgramNamedParameterdvNV_ovr_2(id, len, name, ¶ms);
private static procedure z_GetProgramNamedParameterdvNV_ovr_6(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
private static procedure z_GetProgramNamedParameterdvNV_ovr_6_anh00001(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramNamedParameterdvNV_ovr_6(id, len, name, ¶ms[0]) else
z_GetProgramNamedParameterdvNV_ovr_6_anh00001(id, len, name, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real) :=
z_GetProgramNamedParameterdvNV_ovr_6(id, len, name, ¶ms);
private static procedure z_GetProgramNamedParameterdvNV_ovr_8(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramNamedParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr) :=
z_GetProgramNamedParameterdvNV_ovr_8(id, len, name, ¶ms);
end;
[PCUNotRestore]
glFramebufferMixedSamplesNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RasterSamplesEXT_ovr_0(samples: UInt32; fixedsamplelocations: boolean);
external 'opengl32.dll' name 'glRasterSamplesEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterSamplesEXT(samples: UInt32; fixedsamplelocations: boolean) :=
z_RasterSamplesEXT_ovr_0(samples, fixedsamplelocations);
private static procedure z_CoverageModulationTableNV_ovr_0(n: Int32; var v: single);
external 'opengl32.dll' name 'glCoverageModulationTableNV';
private static procedure z_CoverageModulationTableNV_ovr_0_anh001(n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glCoverageModulationTableNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_CoverageModulationTableNV_ovr_0(n, v[0]) else
z_CoverageModulationTableNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; var v: single) :=
z_CoverageModulationTableNV_ovr_0(n, v);
private static procedure z_CoverageModulationTableNV_ovr_2(n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glCoverageModulationTableNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; v: IntPtr) :=
z_CoverageModulationTableNV_ovr_2(n, v);
private static procedure z_GetCoverageModulationTableNV_ovr_0(bufSize: Int32; var v: single);
external 'opengl32.dll' name 'glGetCoverageModulationTableNV';
private static procedure z_GetCoverageModulationTableNV_ovr_0_anh001(bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetCoverageModulationTableNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_GetCoverageModulationTableNV_ovr_0(bufSize, v[0]) else
z_GetCoverageModulationTableNV_ovr_0_anh001(bufSize, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; var v: single) :=
z_GetCoverageModulationTableNV_ovr_0(bufSize, v);
private static procedure z_GetCoverageModulationTableNV_ovr_2(bufSize: Int32; v: IntPtr);
external 'opengl32.dll' name 'glGetCoverageModulationTableNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; v: IntPtr) :=
z_GetCoverageModulationTableNV_ovr_2(bufSize, v);
private static procedure z_CoverageModulationNV_ovr_0(components: DummyEnum);
external 'opengl32.dll' name 'glCoverageModulationNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationNV(components: DummyEnum) :=
z_CoverageModulationNV_ovr_0(components);
end;
[PCUNotRestore]
glFramebufferMultisampleCoverageNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RenderbufferStorageMultisampleCoverageNV_ovr_0(target: RenderbufferTarget; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
external 'opengl32.dll' name 'glRenderbufferStorageMultisampleCoverageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleCoverageNV(target: RenderbufferTarget; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32) :=
z_RenderbufferStorageMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, _internalformat, width, height);
end;
[PCUNotRestore]
glGeometryProgram4NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramVertexLimitNV_ovr_0(target: ProgramTarget; limit: Int32);
external 'opengl32.dll' name 'glProgramVertexLimitNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramVertexLimitNV(target: ProgramTarget; limit: Int32) :=
z_ProgramVertexLimitNV_ovr_0(target, limit);
private static procedure z_FramebufferTextureEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32);
external 'opengl32.dll' name 'glFramebufferTextureEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureEXT(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32) :=
z_FramebufferTextureEXT_ovr_0(target, attachment, texture, level);
private static procedure z_FramebufferTextureLayerEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
external 'opengl32.dll' name 'glFramebufferTextureLayerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayerEXT(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32) :=
z_FramebufferTextureLayerEXT_ovr_0(target, attachment, texture, level, layer);
private static procedure z_FramebufferTextureFaceEXT_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget);
external 'opengl32.dll' name 'glFramebufferTextureFaceEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureFaceEXT(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget) :=
z_FramebufferTextureFaceEXT_ovr_0(target, attachment, texture, level, face);
end;
[PCUNotRestore]
glGpuProgram4NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramLocalParameterI4iNV_ovr_0(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glProgramLocalParameterI4iNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4iNV(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_ProgramLocalParameterI4iNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameterI4ivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glProgramLocalParameterI4ivNV';
private static procedure z_ProgramLocalParameterI4ivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameterI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameterI4ivNV_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameterI4ivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_ProgramLocalParameterI4ivNV_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameterI4ivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameterI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameterI4ivNV_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParametersI4ivNV_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glProgramLocalParametersI4ivNV';
private static procedure z_ProgramLocalParametersI4ivNV_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParametersI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParametersI4ivNV_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramLocalParametersI4ivNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32) :=
z_ProgramLocalParametersI4ivNV_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramLocalParametersI4ivNV_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParametersI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramLocalParametersI4ivNV_ovr_2(target, index, count, ¶ms);
private static procedure z_ProgramLocalParameterI4uiNV_ovr_0(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
external 'opengl32.dll' name 'glProgramLocalParameterI4uiNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uiNV(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32) :=
z_ProgramLocalParameterI4uiNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramLocalParameterI4uivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramLocalParameterI4uivNV';
private static procedure z_ProgramLocalParameterI4uivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameterI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParameterI4uivNV_ovr_0(target, index, ¶ms[0]) else
z_ProgramLocalParameterI4uivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_ProgramLocalParameterI4uivNV_ovr_0(target, index, ¶ms);
private static procedure z_ProgramLocalParameterI4uivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParameterI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramLocalParameterI4uivNV_ovr_2(target, index, ¶ms);
private static procedure z_ProgramLocalParametersI4uivNV_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramLocalParametersI4uivNV';
private static procedure z_ProgramLocalParametersI4uivNV_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParametersI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramLocalParametersI4uivNV_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramLocalParametersI4uivNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32) :=
z_ProgramLocalParametersI4uivNV_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramLocalParametersI4uivNV_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramLocalParametersI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramLocalParametersI4uivNV_ovr_2(target, index, count, ¶ms);
private static procedure z_ProgramEnvParameterI4iNV_ovr_0(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glProgramEnvParameterI4iNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4iNV(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_ProgramEnvParameterI4iNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameterI4ivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glProgramEnvParameterI4ivNV';
private static procedure z_ProgramEnvParameterI4ivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameterI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameterI4ivNV_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameterI4ivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_ProgramEnvParameterI4ivNV_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameterI4ivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameterI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameterI4ivNV_ovr_2(target, index, ¶ms);
private static procedure z_ProgramEnvParametersI4ivNV_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glProgramEnvParametersI4ivNV';
private static procedure z_ProgramEnvParametersI4ivNV_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParametersI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParametersI4ivNV_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramEnvParametersI4ivNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32) :=
z_ProgramEnvParametersI4ivNV_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramEnvParametersI4ivNV_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParametersI4ivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramEnvParametersI4ivNV_ovr_2(target, index, count, ¶ms);
private static procedure z_ProgramEnvParameterI4uiNV_ovr_0(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
external 'opengl32.dll' name 'glProgramEnvParameterI4uiNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uiNV(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32) :=
z_ProgramEnvParameterI4uiNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramEnvParameterI4uivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramEnvParameterI4uivNV';
private static procedure z_ProgramEnvParameterI4uivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameterI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParameterI4uivNV_ovr_0(target, index, ¶ms[0]) else
z_ProgramEnvParameterI4uivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_ProgramEnvParameterI4uivNV_ovr_0(target, index, ¶ms);
private static procedure z_ProgramEnvParameterI4uivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParameterI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_ProgramEnvParameterI4uivNV_ovr_2(target, index, ¶ms);
private static procedure z_ProgramEnvParametersI4uivNV_ovr_0(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramEnvParametersI4uivNV';
private static procedure z_ProgramEnvParametersI4uivNV_ovr_0_anh00001(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParametersI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramEnvParametersI4uivNV_ovr_0(target, index, count, ¶ms[0]) else
z_ProgramEnvParametersI4uivNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32) :=
z_ProgramEnvParametersI4uivNV_ovr_0(target, index, count, ¶ms);
private static procedure z_ProgramEnvParametersI4uivNV_ovr_2(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramEnvParametersI4uivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramEnvParametersI4uivNV_ovr_2(target, index, count, ¶ms);
private static procedure z_GetProgramLocalParameterIivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramLocalParameterIivNV';
private static procedure z_GetProgramLocalParameterIivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterIivNV_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterIivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_GetProgramLocalParameterIivNV_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterIivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterIivNV_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterIuivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetProgramLocalParameterIuivNV';
private static procedure z_GetProgramLocalParameterIuivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramLocalParameterIuivNV_ovr_0(target, index, ¶ms[0]) else
z_GetProgramLocalParameterIuivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_GetProgramLocalParameterIuivNV_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramLocalParameterIuivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramLocalParameterIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramLocalParameterIuivNV_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterIivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramEnvParameterIivNV';
private static procedure z_GetProgramEnvParameterIivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterIivNV_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterIivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32) :=
z_GetProgramEnvParameterIivNV_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterIivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterIivNV_ovr_2(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterIuivNV_ovr_0(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetProgramEnvParameterIuivNV';
private static procedure z_GetProgramEnvParameterIuivNV_ovr_0_anh0001(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramEnvParameterIuivNV_ovr_0(target, index, ¶ms[0]) else
z_GetProgramEnvParameterIuivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32) :=
z_GetProgramEnvParameterIuivNV_ovr_0(target, index, ¶ms);
private static procedure z_GetProgramEnvParameterIuivNV_ovr_2(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramEnvParameterIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr) :=
z_GetProgramEnvParameterIuivNV_ovr_2(target, index, ¶ms);
end;
[PCUNotRestore]
glGpuProgram5NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramSubroutineParametersuivNV_ovr_0(target: DummyEnum; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramSubroutineParametersuivNV';
private static procedure z_ProgramSubroutineParametersuivNV_ovr_0_anh0001(target: DummyEnum; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramSubroutineParametersuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramSubroutineParametersuivNV_ovr_0(target, count, ¶ms[0]) else
z_ProgramSubroutineParametersuivNV_ovr_0_anh0001(target, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; var ¶ms: UInt32) :=
z_ProgramSubroutineParametersuivNV_ovr_0(target, count, ¶ms);
private static procedure z_ProgramSubroutineParametersuivNV_ovr_2(target: DummyEnum; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramSubroutineParametersuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; ¶ms: IntPtr) :=
z_ProgramSubroutineParametersuivNV_ovr_2(target, count, ¶ms);
private static procedure z_GetProgramSubroutineParameteruivNV_ovr_0(target: DummyEnum; index: UInt32; var param: UInt32);
external 'opengl32.dll' name 'glGetProgramSubroutineParameteruivNV';
private static procedure z_GetProgramSubroutineParameteruivNV_ovr_0_anh0001(target: DummyEnum; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetProgramSubroutineParameteruivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; param: array of UInt32) :=
if (param<>nil) and (param.Length<>0) then
z_GetProgramSubroutineParameteruivNV_ovr_0(target, index, param[0]) else
z_GetProgramSubroutineParameteruivNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; var param: UInt32) :=
z_GetProgramSubroutineParameteruivNV_ovr_0(target, index, param);
private static procedure z_GetProgramSubroutineParameteruivNV_ovr_2(target: DummyEnum; index: UInt32; param: IntPtr);
external 'opengl32.dll' name 'glGetProgramSubroutineParameteruivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; param: IntPtr) :=
z_GetProgramSubroutineParameteruivNV_ovr_2(target, index, param);
end;
[PCUNotRestore]
glGpuShader5NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Uniform1i64NV_ovr_0(location: Int32; x: Int64);
external 'opengl32.dll' name 'glUniform1i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64NV(location: Int32; x: Int64) :=
z_Uniform1i64NV_ovr_0(location, x);
private static procedure z_Uniform2i64NV_ovr_0(location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glUniform2i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64NV(location: Int32; x: Int64; y: Int64) :=
z_Uniform2i64NV_ovr_0(location, x, y);
private static procedure z_Uniform3i64NV_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glUniform3i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64NV(location: Int32; x: Int64; y: Int64; z: Int64) :=
z_Uniform3i64NV_ovr_0(location, x, y, z);
private static procedure z_Uniform4i64NV_ovr_0(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glUniform4i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64NV(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_Uniform4i64NV_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform1i64vNV';
private static procedure z_Uniform1i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1i64vNV_ovr_0(location, count, value[0]) else
z_Uniform1i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform1i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform1i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform2i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform2i64vNV';
private static procedure z_Uniform2i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2i64vNV_ovr_0(location, count, value[0]) else
z_Uniform2i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform2i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform2i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform3i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform3i64vNV';
private static procedure z_Uniform3i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3i64vNV_ovr_0(location, count, value[0]) else
z_Uniform3i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform3i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform3i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform4i64vNV_ovr_0(location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glUniform4i64vNV';
private static procedure z_Uniform4i64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4i64vNV_ovr_0(location, count, value[0]) else
z_Uniform4i64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; var value: Int64) :=
z_Uniform4i64vNV_ovr_0(location, count, value);
private static procedure z_Uniform4i64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4i64vNV_ovr_2(location, count, value);
private static procedure z_Uniform1ui64NV_ovr_0(location: Int32; x: UInt64);
external 'opengl32.dll' name 'glUniform1ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64NV(location: Int32; x: UInt64) :=
z_Uniform1ui64NV_ovr_0(location, x);
private static procedure z_Uniform2ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glUniform2ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64NV(location: Int32; x: UInt64; y: UInt64) :=
z_Uniform2ui64NV_ovr_0(location, x, y);
private static procedure z_Uniform3ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glUniform3ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_Uniform3ui64NV_ovr_0(location, x, y, z);
private static procedure z_Uniform4ui64NV_ovr_0(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glUniform4ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_Uniform4ui64NV_ovr_0(location, x, y, z, w);
private static procedure z_Uniform1ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform1ui64vNV';
private static procedure z_Uniform1ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform1ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform1ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform1ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform1ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform1ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform2ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform2ui64vNV';
private static procedure z_Uniform2ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform2ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform2ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform2ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform2ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform2ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform3ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform3ui64vNV';
private static procedure z_Uniform3ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform3ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform3ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform3ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform3ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform3ui64vNV_ovr_2(location, count, value);
private static procedure z_Uniform4ui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniform4ui64vNV';
private static procedure z_Uniform4ui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniform4ui64vNV_ovr_0(location, count, value[0]) else
z_Uniform4ui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniform4ui64vNV_ovr_0(location, count, value);
private static procedure z_Uniform4ui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniform4ui64vNV_ovr_2(location, count, value);
private static procedure z_GetUniformi64vNV_ovr_0(&program: UInt32; location: Int32; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetUniformi64vNV';
private static procedure z_GetUniformi64vNV_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformi64vNV_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; var ¶ms: Int64) :=
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformi64vNV_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformi64vNV_ovr_2(&program, location, ¶ms);
private static procedure z_ProgramUniform1i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64NV(&program: UInt32; location: Int32; x: Int64) :=
z_ProgramUniform1i64NV_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64) :=
z_ProgramUniform2i64NV_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64) :=
z_ProgramUniform3i64NV_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4i64NV_ovr_0(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_ProgramUniform4i64NV_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
private static procedure z_ProgramUniform1i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
private static procedure z_ProgramUniform2i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
private static procedure z_ProgramUniform3i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4i64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: Int64);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
private static procedure z_ProgramUniform4i64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4i64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64) :=
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4i64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4i64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform1ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64NV(&program: UInt32; location: Int32; x: UInt64) :=
z_ProgramUniform1ui64NV_ovr_0(&program, location, x);
private static procedure z_ProgramUniform2ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64) :=
z_ProgramUniform2ui64NV_ovr_0(&program, location, x, y);
private static procedure z_ProgramUniform3ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64) :=
z_ProgramUniform3ui64NV_ovr_0(&program, location, x, y, z);
private static procedure z_ProgramUniform4ui64NV_ovr_0(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_ProgramUniform4ui64NV_ovr_0(&program, location, x, y, z, w);
private static procedure z_ProgramUniform1ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
private static procedure z_ProgramUniform1ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform1ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform1ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform1ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
private static procedure z_ProgramUniform2ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform2ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform2ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform2ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
private static procedure z_ProgramUniform3ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform3ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform3ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform3ui64vNV_ovr_2(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
private static procedure z_ProgramUniform4ui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniform4ui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniform4ui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniform4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniform4ui64vNV_ovr_2(&program, location, count, value);
end;
[PCUNotRestore]
glHalfFloatNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Vertex2hNV_ovr_0(x: Half; y: Half);
external 'opengl32.dll' name 'glVertex2hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hNV(x: Half; y: Half) :=
z_Vertex2hNV_ovr_0(x, y);
private static procedure z_Vertex2hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glVertex2hvNV';
private static procedure z_Vertex2hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex2hvNV_ovr_0(v[0]) else
z_Vertex2hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(var v: Half) :=
z_Vertex2hvNV_ovr_0(v);
private static procedure z_Vertex2hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(v: IntPtr) :=
z_Vertex2hvNV_ovr_2(v);
private static procedure z_Vertex3hNV_ovr_0(x: Half; y: Half; z: Half);
external 'opengl32.dll' name 'glVertex3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hNV(x: Half; y: Half; z: Half) :=
z_Vertex3hNV_ovr_0(x, y, z);
private static procedure z_Vertex3hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glVertex3hvNV';
private static procedure z_Vertex3hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex3hvNV_ovr_0(v[0]) else
z_Vertex3hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(var v: Half) :=
z_Vertex3hvNV_ovr_0(v);
private static procedure z_Vertex3hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(v: IntPtr) :=
z_Vertex3hvNV_ovr_2(v);
private static procedure z_Vertex4hNV_ovr_0(x: Half; y: Half; z: Half; w: Half);
external 'opengl32.dll' name 'glVertex4hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hNV(x: Half; y: Half; z: Half; w: Half) :=
z_Vertex4hNV_ovr_0(x, y, z, w);
private static procedure z_Vertex4hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glVertex4hvNV';
private static procedure z_Vertex4hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glVertex4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Vertex4hvNV_ovr_0(v[0]) else
z_Vertex4hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(var v: Half) :=
z_Vertex4hvNV_ovr_0(v);
private static procedure z_Vertex4hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(v: IntPtr) :=
z_Vertex4hvNV_ovr_2(v);
private static procedure z_Normal3hNV_ovr_0(nx: Half; ny: Half; nz: Half);
external 'opengl32.dll' name 'glNormal3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hNV(nx: Half; ny: Half; nz: Half) :=
z_Normal3hNV_ovr_0(nx, ny, nz);
private static procedure z_Normal3hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glNormal3hvNV';
private static procedure z_Normal3hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glNormal3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Normal3hvNV_ovr_0(v[0]) else
z_Normal3hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(var v: Half) :=
z_Normal3hvNV_ovr_0(v);
private static procedure z_Normal3hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(v: IntPtr) :=
z_Normal3hvNV_ovr_2(v);
private static procedure z_Color3hNV_ovr_0(red: Half; green: Half; blue: Half);
external 'opengl32.dll' name 'glColor3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hNV(red: Half; green: Half; blue: Half) :=
z_Color3hNV_ovr_0(red, green, blue);
private static procedure z_Color3hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glColor3hvNV';
private static procedure z_Color3hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Color3hvNV_ovr_0(v[0]) else
z_Color3hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(var v: Half) :=
z_Color3hvNV_ovr_0(v);
private static procedure z_Color3hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(v: IntPtr) :=
z_Color3hvNV_ovr_2(v);
private static procedure z_Color4hNV_ovr_0(red: Half; green: Half; blue: Half; alpha: Half);
external 'opengl32.dll' name 'glColor4hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hNV(red: Half; green: Half; blue: Half; alpha: Half) :=
z_Color4hNV_ovr_0(red, green, blue, alpha);
private static procedure z_Color4hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glColor4hvNV';
private static procedure z_Color4hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glColor4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_Color4hvNV_ovr_0(v[0]) else
z_Color4hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(var v: Half) :=
z_Color4hvNV_ovr_0(v);
private static procedure z_Color4hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glColor4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(v: IntPtr) :=
z_Color4hvNV_ovr_2(v);
private static procedure z_TexCoord1hNV_ovr_0(s: Half);
external 'opengl32.dll' name 'glTexCoord1hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hNV(s: Half) :=
z_TexCoord1hNV_ovr_0(s);
private static procedure z_TexCoord1hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glTexCoord1hvNV';
private static procedure z_TexCoord1hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord1hvNV_ovr_0(v[0]) else
z_TexCoord1hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(var v: Half) :=
z_TexCoord1hvNV_ovr_0(v);
private static procedure z_TexCoord1hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(v: IntPtr) :=
z_TexCoord1hvNV_ovr_2(v);
private static procedure z_TexCoord2hNV_ovr_0(s: Half; t: Half);
external 'opengl32.dll' name 'glTexCoord2hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hNV(s: Half; t: Half) :=
z_TexCoord2hNV_ovr_0(s, t);
private static procedure z_TexCoord2hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glTexCoord2hvNV';
private static procedure z_TexCoord2hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord2hvNV_ovr_0(v[0]) else
z_TexCoord2hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(var v: Half) :=
z_TexCoord2hvNV_ovr_0(v);
private static procedure z_TexCoord2hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(v: IntPtr) :=
z_TexCoord2hvNV_ovr_2(v);
private static procedure z_TexCoord3hNV_ovr_0(s: Half; t: Half; r: Half);
external 'opengl32.dll' name 'glTexCoord3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hNV(s: Half; t: Half; r: Half) :=
z_TexCoord3hNV_ovr_0(s, t, r);
private static procedure z_TexCoord3hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glTexCoord3hvNV';
private static procedure z_TexCoord3hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord3hvNV_ovr_0(v[0]) else
z_TexCoord3hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(var v: Half) :=
z_TexCoord3hvNV_ovr_0(v);
private static procedure z_TexCoord3hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(v: IntPtr) :=
z_TexCoord3hvNV_ovr_2(v);
private static procedure z_TexCoord4hNV_ovr_0(s: Half; t: Half; r: Half; q: Half);
external 'opengl32.dll' name 'glTexCoord4hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hNV(s: Half; t: Half; r: Half; q: Half) :=
z_TexCoord4hNV_ovr_0(s, t, r, q);
private static procedure z_TexCoord4hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glTexCoord4hvNV';
private static procedure z_TexCoord4hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_TexCoord4hvNV_ovr_0(v[0]) else
z_TexCoord4hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(var v: Half) :=
z_TexCoord4hvNV_ovr_0(v);
private static procedure z_TexCoord4hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(v: IntPtr) :=
z_TexCoord4hvNV_ovr_2(v);
private static procedure z_MultiTexCoord1hNV_ovr_0(target: TextureUnit; s: Half);
external 'opengl32.dll' name 'glMultiTexCoord1hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hNV(target: TextureUnit; s: Half) :=
z_MultiTexCoord1hNV_ovr_0(target, s);
private static procedure z_MultiTexCoord1hvNV_ovr_0(target: TextureUnit; var v: Half);
external 'opengl32.dll' name 'glMultiTexCoord1hvNV';
private static procedure z_MultiTexCoord1hvNV_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord1hvNV_ovr_0(target, v[0]) else
z_MultiTexCoord1hvNV_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; var v: Half) :=
z_MultiTexCoord1hvNV_ovr_0(target, v);
private static procedure z_MultiTexCoord1hvNV_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord1hvNV_ovr_2(target, v);
private static procedure z_MultiTexCoord2hNV_ovr_0(target: TextureUnit; s: Half; t: Half);
external 'opengl32.dll' name 'glMultiTexCoord2hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hNV(target: TextureUnit; s: Half; t: Half) :=
z_MultiTexCoord2hNV_ovr_0(target, s, t);
private static procedure z_MultiTexCoord2hvNV_ovr_0(target: TextureUnit; var v: Half);
external 'opengl32.dll' name 'glMultiTexCoord2hvNV';
private static procedure z_MultiTexCoord2hvNV_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord2hvNV_ovr_0(target, v[0]) else
z_MultiTexCoord2hvNV_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; var v: Half) :=
z_MultiTexCoord2hvNV_ovr_0(target, v);
private static procedure z_MultiTexCoord2hvNV_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord2hvNV_ovr_2(target, v);
private static procedure z_MultiTexCoord3hNV_ovr_0(target: TextureUnit; s: Half; t: Half; r: Half);
external 'opengl32.dll' name 'glMultiTexCoord3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hNV(target: TextureUnit; s: Half; t: Half; r: Half) :=
z_MultiTexCoord3hNV_ovr_0(target, s, t, r);
private static procedure z_MultiTexCoord3hvNV_ovr_0(target: TextureUnit; var v: Half);
external 'opengl32.dll' name 'glMultiTexCoord3hvNV';
private static procedure z_MultiTexCoord3hvNV_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord3hvNV_ovr_0(target, v[0]) else
z_MultiTexCoord3hvNV_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; var v: Half) :=
z_MultiTexCoord3hvNV_ovr_0(target, v);
private static procedure z_MultiTexCoord3hvNV_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord3hvNV_ovr_2(target, v);
private static procedure z_MultiTexCoord4hNV_ovr_0(target: TextureUnit; s: Half; t: Half; r: Half; q: Half);
external 'opengl32.dll' name 'glMultiTexCoord4hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hNV(target: TextureUnit; s: Half; t: Half; r: Half; q: Half) :=
z_MultiTexCoord4hNV_ovr_0(target, s, t, r, q);
private static procedure z_MultiTexCoord4hvNV_ovr_0(target: TextureUnit; var v: Half);
external 'opengl32.dll' name 'glMultiTexCoord4hvNV';
private static procedure z_MultiTexCoord4hvNV_ovr_0_anh001(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_MultiTexCoord4hvNV_ovr_0(target, v[0]) else
z_MultiTexCoord4hvNV_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; var v: Half) :=
z_MultiTexCoord4hvNV_ovr_0(target, v);
private static procedure z_MultiTexCoord4hvNV_ovr_2(target: TextureUnit; v: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; v: IntPtr) :=
z_MultiTexCoord4hvNV_ovr_2(target, v);
private static procedure z_FogCoordhNV_ovr_0(fog: Half);
external 'opengl32.dll' name 'glFogCoordhNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhNV(fog: Half) :=
z_FogCoordhNV_ovr_0(fog);
private static procedure z_FogCoordhvNV_ovr_0(var fog: Half);
external 'opengl32.dll' name 'glFogCoordhvNV';
private static procedure z_FogCoordhvNV_ovr_0_anh01(fog: IntPtr);
external 'opengl32.dll' name 'glFogCoordhvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(fog: array of Half) :=
if (fog<>nil) and (fog.Length<>0) then
z_FogCoordhvNV_ovr_0(fog[0]) else
z_FogCoordhvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(var fog: Half) :=
z_FogCoordhvNV_ovr_0(fog);
private static procedure z_FogCoordhvNV_ovr_2(fog: IntPtr);
external 'opengl32.dll' name 'glFogCoordhvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(fog: IntPtr) :=
z_FogCoordhvNV_ovr_2(fog);
private static procedure z_SecondaryColor3hNV_ovr_0(red: Half; green: Half; blue: Half);
external 'opengl32.dll' name 'glSecondaryColor3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hNV(red: Half; green: Half; blue: Half) :=
z_SecondaryColor3hNV_ovr_0(red, green, blue);
private static procedure z_SecondaryColor3hvNV_ovr_0(var v: Half);
external 'opengl32.dll' name 'glSecondaryColor3hvNV';
private static procedure z_SecondaryColor3hvNV_ovr_0_anh01(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_SecondaryColor3hvNV_ovr_0(v[0]) else
z_SecondaryColor3hvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(var v: Half) :=
z_SecondaryColor3hvNV_ovr_0(v);
private static procedure z_SecondaryColor3hvNV_ovr_2(v: IntPtr);
external 'opengl32.dll' name 'glSecondaryColor3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(v: IntPtr) :=
z_SecondaryColor3hvNV_ovr_2(v);
private static procedure z_VertexWeighthNV_ovr_0(weight: Half);
external 'opengl32.dll' name 'glVertexWeighthNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthNV(weight: Half) :=
z_VertexWeighthNV_ovr_0(weight);
private static procedure z_VertexWeighthvNV_ovr_0(var weight: Half);
external 'opengl32.dll' name 'glVertexWeighthvNV';
private static procedure z_VertexWeighthvNV_ovr_0_anh01(weight: IntPtr);
external 'opengl32.dll' name 'glVertexWeighthvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(weight: array of Half) :=
if (weight<>nil) and (weight.Length<>0) then
z_VertexWeighthvNV_ovr_0(weight[0]) else
z_VertexWeighthvNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(var weight: Half) :=
z_VertexWeighthvNV_ovr_0(weight);
private static procedure z_VertexWeighthvNV_ovr_2(weight: IntPtr);
external 'opengl32.dll' name 'glVertexWeighthvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(weight: IntPtr) :=
z_VertexWeighthvNV_ovr_2(weight);
private static procedure z_VertexAttrib1hNV_ovr_0(index: UInt32; x: Half);
external 'opengl32.dll' name 'glVertexAttrib1hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hNV(index: UInt32; x: Half) :=
z_VertexAttrib1hNV_ovr_0(index, x);
private static procedure z_VertexAttrib1hvNV_ovr_0(index: UInt32; var v: Half);
external 'opengl32.dll' name 'glVertexAttrib1hvNV';
private static procedure z_VertexAttrib1hvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1hvNV_ovr_0(index, v[0]) else
z_VertexAttrib1hvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; var v: Half) :=
z_VertexAttrib1hvNV_ovr_0(index, v);
private static procedure z_VertexAttrib1hvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib1hvNV_ovr_2(index, v);
private static procedure z_VertexAttrib2hNV_ovr_0(index: UInt32; x: Half; y: Half);
external 'opengl32.dll' name 'glVertexAttrib2hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hNV(index: UInt32; x: Half; y: Half) :=
z_VertexAttrib2hNV_ovr_0(index, x, y);
private static procedure z_VertexAttrib2hvNV_ovr_0(index: UInt32; var v: Half);
external 'opengl32.dll' name 'glVertexAttrib2hvNV';
private static procedure z_VertexAttrib2hvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2hvNV_ovr_0(index, v[0]) else
z_VertexAttrib2hvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; var v: Half) :=
z_VertexAttrib2hvNV_ovr_0(index, v);
private static procedure z_VertexAttrib2hvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib2hvNV_ovr_2(index, v);
private static procedure z_VertexAttrib3hNV_ovr_0(index: UInt32; x: Half; y: Half; z: Half);
external 'opengl32.dll' name 'glVertexAttrib3hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hNV(index: UInt32; x: Half; y: Half; z: Half) :=
z_VertexAttrib3hNV_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3hvNV_ovr_0(index: UInt32; var v: Half);
external 'opengl32.dll' name 'glVertexAttrib3hvNV';
private static procedure z_VertexAttrib3hvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3hvNV_ovr_0(index, v[0]) else
z_VertexAttrib3hvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; var v: Half) :=
z_VertexAttrib3hvNV_ovr_0(index, v);
private static procedure z_VertexAttrib3hvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib3hvNV_ovr_2(index, v);
private static procedure z_VertexAttrib4hNV_ovr_0(index: UInt32; x: Half; y: Half; z: Half; w: Half);
external 'opengl32.dll' name 'glVertexAttrib4hNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hNV(index: UInt32; x: Half; y: Half; z: Half; w: Half) :=
z_VertexAttrib4hNV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4hvNV_ovr_0(index: UInt32; var v: Half);
external 'opengl32.dll' name 'glVertexAttrib4hvNV';
private static procedure z_VertexAttrib4hvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4hvNV_ovr_0(index, v[0]) else
z_VertexAttrib4hvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; var v: Half) :=
z_VertexAttrib4hvNV_ovr_0(index, v);
private static procedure z_VertexAttrib4hvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib4hvNV_ovr_2(index, v);
private static procedure z_VertexAttribs1hvNV_ovr_0(index: UInt32; n: Int32; var v: Half);
external 'opengl32.dll' name 'glVertexAttribs1hvNV';
private static procedure z_VertexAttribs1hvNV_ovr_0_anh0001(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs1hvNV_ovr_0(index, n, v[0]) else
z_VertexAttribs1hvNV_ovr_0_anh0001(index, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; var v: Half) :=
z_VertexAttribs1hvNV_ovr_0(index, n, v);
private static procedure z_VertexAttribs1hvNV_ovr_2(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; v: IntPtr) :=
z_VertexAttribs1hvNV_ovr_2(index, n, v);
private static procedure z_VertexAttribs2hvNV_ovr_0(index: UInt32; n: Int32; var v: Half);
external 'opengl32.dll' name 'glVertexAttribs2hvNV';
private static procedure z_VertexAttribs2hvNV_ovr_0_anh0001(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs2hvNV_ovr_0(index, n, v[0]) else
z_VertexAttribs2hvNV_ovr_0_anh0001(index, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; var v: Half) :=
z_VertexAttribs2hvNV_ovr_0(index, n, v);
private static procedure z_VertexAttribs2hvNV_ovr_2(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; v: IntPtr) :=
z_VertexAttribs2hvNV_ovr_2(index, n, v);
private static procedure z_VertexAttribs3hvNV_ovr_0(index: UInt32; n: Int32; var v: Half);
external 'opengl32.dll' name 'glVertexAttribs3hvNV';
private static procedure z_VertexAttribs3hvNV_ovr_0_anh0001(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs3hvNV_ovr_0(index, n, v[0]) else
z_VertexAttribs3hvNV_ovr_0_anh0001(index, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; var v: Half) :=
z_VertexAttribs3hvNV_ovr_0(index, n, v);
private static procedure z_VertexAttribs3hvNV_ovr_2(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; v: IntPtr) :=
z_VertexAttribs3hvNV_ovr_2(index, n, v);
private static procedure z_VertexAttribs4hvNV_ovr_0(index: UInt32; n: Int32; var v: Half);
external 'opengl32.dll' name 'glVertexAttribs4hvNV';
private static procedure z_VertexAttribs4hvNV_ovr_0_anh0001(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; v: array of Half) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs4hvNV_ovr_0(index, n, v[0]) else
z_VertexAttribs4hvNV_ovr_0_anh0001(index, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; var v: Half) :=
z_VertexAttribs4hvNV_ovr_0(index, n, v);
private static procedure z_VertexAttribs4hvNV_ovr_2(index: UInt32; n: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4hvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; v: IntPtr) :=
z_VertexAttribs4hvNV_ovr_2(index, n, v);
end;
[PCUNotRestore]
glInternalformatSampleQueryNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetInternalformatSampleivNV_ovr_0(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetInternalformatSampleivNV';
private static procedure z_GetInternalformatSampleivNV_ovr_0_anh0000001(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformatSampleivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetInternalformatSampleivNV_ovr_0(target, _internalformat, samples, pname, count, ¶ms[0]) else
z_GetInternalformatSampleivNV_ovr_0_anh0000001(target, _internalformat, samples, pname, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; var ¶ms: Int32) :=
z_GetInternalformatSampleivNV_ovr_0(target, _internalformat, samples, pname, count, ¶ms);
private static procedure z_GetInternalformatSampleivNV_ovr_2(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetInternalformatSampleivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr) :=
z_GetInternalformatSampleivNV_ovr_2(target, _internalformat, samples, pname, count, ¶ms);
end;
[PCUNotRestore]
glGpuMulticastNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_RenderGpuMaskNV_ovr_0(mask: DummyFlags);
external 'opengl32.dll' name 'glRenderGpuMaskNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderGpuMaskNV(mask: DummyFlags) :=
z_RenderGpuMaskNV_ovr_0(mask);
private static procedure z_MulticastBufferSubDataNV_ovr_0(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
external 'opengl32.dll' name 'glMulticastBufferSubDataNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastBufferSubDataNV(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr) :=
z_MulticastBufferSubDataNV_ovr_0(gpuMask, buffer, offset, size, data);
private static procedure z_MulticastCopyBufferSubDataNV_ovr_0(readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glMulticastCopyBufferSubDataNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastCopyBufferSubDataNV(readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr) :=
z_MulticastCopyBufferSubDataNV_ovr_0(readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size);
private static procedure z_MulticastCopyImageSubDataNV_ovr_0(srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32);
external 'opengl32.dll' name 'glMulticastCopyImageSubDataNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastCopyImageSubDataNV(srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32) :=
z_MulticastCopyImageSubDataNV_ovr_0(srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
private static procedure z_MulticastBlitFramebufferNV_ovr_0(srcGpu: UInt32; dstGpu: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: DummyEnum);
external 'opengl32.dll' name 'glMulticastBlitFramebufferNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastBlitFramebufferNV(srcGpu: UInt32; dstGpu: UInt32; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: ClearBufferMask; filter: DummyEnum) :=
z_MulticastBlitFramebufferNV_ovr_0(srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
private static procedure z_MulticastFramebufferSampleLocationsfvNV_ovr_0(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glMulticastFramebufferSampleLocationsfvNV';
private static procedure z_MulticastFramebufferSampleLocationsfvNV_ovr_0_anh000001(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MulticastFramebufferSampleLocationsfvNV_ovr_0(gpu, framebuffer, start, count, v[0]) else
z_MulticastFramebufferSampleLocationsfvNV_ovr_0_anh000001(gpu, framebuffer, start, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; var v: single) :=
z_MulticastFramebufferSampleLocationsfvNV_ovr_0(gpu, framebuffer, start, count, v);
private static procedure z_MulticastFramebufferSampleLocationsfvNV_ovr_2(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr) :=
z_MulticastFramebufferSampleLocationsfvNV_ovr_2(gpu, framebuffer, start, count, v);
private static procedure z_MulticastBarrierNV_ovr_0;
external 'opengl32.dll' name 'glMulticastBarrierNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastBarrierNV :=
z_MulticastBarrierNV_ovr_0;
private static procedure z_MulticastWaitSyncNV_ovr_0(signalGpu: UInt32; waitGpuMask: DummyFlags);
external 'opengl32.dll' name 'glMulticastWaitSyncNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastWaitSyncNV(signalGpu: UInt32; waitGpuMask: DummyFlags) :=
z_MulticastWaitSyncNV_ovr_0(signalGpu, waitGpuMask);
private static procedure z_MulticastGetQueryObjectivNV_ovr_0(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glMulticastGetQueryObjectivNV';
private static procedure z_MulticastGetQueryObjectivNV_ovr_0_anh00001(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MulticastGetQueryObjectivNV_ovr_0(gpu, id, pname, ¶ms[0]) else
z_MulticastGetQueryObjectivNV_ovr_0_anh00001(gpu, id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_MulticastGetQueryObjectivNV_ovr_0(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjectivNV_ovr_2(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_MulticastGetQueryObjectivNV_ovr_2(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjectuivNV_ovr_0(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt32);
external 'opengl32.dll' name 'glMulticastGetQueryObjectuivNV';
private static procedure z_MulticastGetQueryObjectuivNV_ovr_0_anh00001(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MulticastGetQueryObjectuivNV_ovr_0(gpu, id, pname, ¶ms[0]) else
z_MulticastGetQueryObjectuivNV_ovr_0_anh00001(gpu, id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt32) :=
z_MulticastGetQueryObjectuivNV_ovr_0(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjectuivNV_ovr_2(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_MulticastGetQueryObjectuivNV_ovr_2(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjecti64vNV_ovr_0(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int64);
external 'opengl32.dll' name 'glMulticastGetQueryObjecti64vNV';
private static procedure z_MulticastGetQueryObjecti64vNV_ovr_0_anh00001(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjecti64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MulticastGetQueryObjecti64vNV_ovr_0(gpu, id, pname, ¶ms[0]) else
z_MulticastGetQueryObjecti64vNV_ovr_0_anh00001(gpu, id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int64) :=
z_MulticastGetQueryObjecti64vNV_ovr_0(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjecti64vNV_ovr_2(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjecti64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_MulticastGetQueryObjecti64vNV_ovr_2(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjectui64vNV_ovr_0(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt64);
external 'opengl32.dll' name 'glMulticastGetQueryObjectui64vNV';
private static procedure z_MulticastGetQueryObjectui64vNV_ovr_0_anh00001(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_MulticastGetQueryObjectui64vNV_ovr_0(gpu, id, pname, ¶ms[0]) else
z_MulticastGetQueryObjectui64vNV_ovr_0_anh00001(gpu, id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt64) :=
z_MulticastGetQueryObjectui64vNV_ovr_0(gpu, id, pname, ¶ms);
private static procedure z_MulticastGetQueryObjectui64vNV_ovr_2(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMulticastGetQueryObjectui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_MulticastGetQueryObjectui64vNV_ovr_2(gpu, id, pname, ¶ms);
end;
[PCUNotRestore]
glGpuMulticast2NVX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_UploadGpuMaskNVX_ovr_0(mask: DummyFlags);
external 'opengl32.dll' name 'glUploadGpuMaskNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UploadGpuMaskNVX(mask: DummyFlags) :=
z_UploadGpuMaskNVX_ovr_0(mask);
private static procedure z_MulticastViewportArrayvNVX_ovr_0(gpu: UInt32; first: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glMulticastViewportArrayvNVX';
private static procedure z_MulticastViewportArrayvNVX_ovr_0_anh00001(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastViewportArrayvNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_MulticastViewportArrayvNVX_ovr_0(gpu, first, count, v[0]) else
z_MulticastViewportArrayvNVX_ovr_0_anh00001(gpu, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; var v: single) :=
z_MulticastViewportArrayvNVX_ovr_0(gpu, first, count, v);
private static procedure z_MulticastViewportArrayvNVX_ovr_2(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastViewportArrayvNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr) :=
z_MulticastViewportArrayvNVX_ovr_2(gpu, first, count, v);
private static procedure z_MulticastViewportPositionWScaleNVX_ovr_0(gpu: UInt32; index: UInt32; xcoeff: single; ycoeff: single);
external 'opengl32.dll' name 'glMulticastViewportPositionWScaleNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportPositionWScaleNVX(gpu: UInt32; index: UInt32; xcoeff: single; ycoeff: single) :=
z_MulticastViewportPositionWScaleNVX_ovr_0(gpu, index, xcoeff, ycoeff);
private static procedure z_MulticastScissorArrayvNVX_ovr_0(gpu: UInt32; first: UInt32; count: Int32; var v: Int32);
external 'opengl32.dll' name 'glMulticastScissorArrayvNVX';
private static procedure z_MulticastScissorArrayvNVX_ovr_0_anh00001(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastScissorArrayvNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_MulticastScissorArrayvNVX_ovr_0(gpu, first, count, v[0]) else
z_MulticastScissorArrayvNVX_ovr_0_anh00001(gpu, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; var v: Int32) :=
z_MulticastScissorArrayvNVX_ovr_0(gpu, first, count, v);
private static procedure z_MulticastScissorArrayvNVX_ovr_2(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glMulticastScissorArrayvNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr) :=
z_MulticastScissorArrayvNVX_ovr_2(gpu, first, count, v);
private static function z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000011(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000011(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000011(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00010000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_1_anh00110000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_2_anh00110000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00110000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00010000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_3_anh00110000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_4_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_4_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_4_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_5_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_5_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_5_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_6_anh00110000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00110000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_7_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_7_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_7_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_8_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_8_anh00010000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_8_anh00110000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_8_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_8_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_8_anh00110000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_9_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_9_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_9_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_9_anh00100000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000011(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_10_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_10_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_11_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_11_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_12_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_12_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_13_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_14_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_15_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_15_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_16_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_17_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_8_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000011(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_19_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_19_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_19_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_20_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_20_anh00000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_20_anh00100000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_20_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_20_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_20_anh00100000000010(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_21_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_21_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_22_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_23_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_20_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_24_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_24_anh00000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_24_anh00100000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_24_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_24_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_24_anh00100000000001(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_25_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_24_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_26(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_26_anh00100000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_26_anh00100000000000(waitSemaphoreCount, IntPtr.Zero, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000011(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_8_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_2_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_0_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_6_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_20_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_18_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_24_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000011(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_55_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_55_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_55_anh00010000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_56_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_56_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_56_anh00010000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_56_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_56_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_56_anh00010000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_57_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_57_anh00010000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_58_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_59_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_56_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_60_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_60_anh00000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_60_anh00010000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_60_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_60_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_60_anh00010000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_61_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_60_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_62(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_62_anh00010000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: array of UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_62_anh00010000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_56_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_54_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_60_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var fenceValueArray: UInt64; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000011(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyBufferSubDataNVX_ovr_73_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_74(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_74_anh00000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyBufferSubDataNVX_ovr_74_anh00000000000010(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_72_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_78(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
private static function z_AsyncCopyBufferSubDataNVX_ovr_78_anh00000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyBufferSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyBufferSubDataNVX_ovr_78_anh00000000000001(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyBufferSubDataNVX_ovr_80(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyBufferSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyBufferSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; fenceValueArray: IntPtr; readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyBufferSubDataNVX_ovr_80(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000011(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000011(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000011(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh000100000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_1_anh001100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_2_anh001100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh001100000000000000000010(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh000100000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_3_anh001100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_4_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_4_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_4_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_5_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_5_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_5_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh000000000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_6_anh001100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh001100000000000000000001(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_7_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_7_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_7_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_8(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_8_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_8_anh000100000000000000000000(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_8_anh001100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_8_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray[0], IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_8_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_8_anh001100000000000000000000(waitSemaphoreCount, IntPtr.Zero, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_9_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_9_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_9_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_9_anh001000000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000011(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_10_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_10_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_11_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_11_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_12_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_12_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_13_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_14_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_15_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_15_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_16_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_17_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_8_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000011(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000011(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_19_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_19_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_19_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_20(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_20_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_20_anh000000000000000000000010(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_20_anh001000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_20_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_20_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_20_anh001000000000000000000010(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_21_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_21_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_22_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_23_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_20_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_24(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_24_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_24_anh000000000000000000000001(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_24_anh001000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_24_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_24_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_24_anh001000000000000000000001(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_25_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_24_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_26(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_26_anh001000000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: array of UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitSemaphoreArray<>nil) and (waitSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray[0], waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_26_anh001000000000000000000000(waitSemaphoreCount, IntPtr.Zero, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000011(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_8_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_2_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_0_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_6_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_20_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_18_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_24_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; var waitSemaphoreArray: UInt32; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000011(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_55_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_55_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_55_anh000100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_56(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_56_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_56_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_56_anh000100000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_56_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray) else
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_56_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_56_anh000100000000000000000010(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_57_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_57_anh000100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_58_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_59_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_56_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_60(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_60_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_60_anh000000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_60_anh000100000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_60_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_60_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_60_anh000100000000000000000001(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_61_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_60_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_62(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_62_anh000100000000000000000000(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: array of UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
if (waitValueArray<>nil) and (waitValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, waitValueArray[0], srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_62_anh000100000000000000000000(waitSemaphoreCount, waitSemaphoreArray, IntPtr.Zero, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_56_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_54_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_60_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; var waitValueArray: UInt64; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_72(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000011(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], IntPtr.Zero) else
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000011(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, IntPtr.Zero);
private static function z_AsyncCopyImageSubDataNVX_ovr_73_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; var signalValueArray: UInt64): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_74(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_74_anh000000000000000000000010(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: array of UInt32; signalValueArray: IntPtr): UInt32 :=
if (signalSemaphoreArray<>nil) and (signalSemaphoreArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray) else
z_AsyncCopyImageSubDataNVX_ovr_74_anh000000000000000000000010(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, IntPtr.Zero, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_72_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; var signalSemaphoreArray: UInt32; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_78(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
private static function z_AsyncCopyImageSubDataNVX_ovr_78_anh000000000000000000000001(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: array of UInt64): UInt32 :=
if (signalValueArray<>nil) and (signalValueArray.Length<>0) then
z_AsyncCopyImageSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]) else
z_AsyncCopyImageSubDataNVX_ovr_78_anh000000000000000000000001(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; var signalValueArray: UInt64): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
private static function z_AsyncCopyImageSubDataNVX_ovr_80(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32;
external 'opengl32.dll' name 'glAsyncCopyImageSubDataNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AsyncCopyImageSubDataNVX(waitSemaphoreCount: Int32; waitSemaphoreArray: IntPtr; waitValueArray: IntPtr; srcGpu: UInt32; dstGpuMask: DummyFlags; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; srcWidth: Int32; srcHeight: Int32; srcDepth: Int32; signalSemaphoreCount: Int32; signalSemaphoreArray: IntPtr; signalValueArray: IntPtr): UInt32 :=
z_AsyncCopyImageSubDataNVX_ovr_80(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
[PCUNotRestore]
glProgressFenceNVX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_CreateProgressFenceNVX_ovr_0: UInt32;
external 'opengl32.dll' name 'glCreateProgressFenceNVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgressFenceNVX: UInt32 :=
z_CreateProgressFenceNVX_ovr_0;
private static procedure z_SignalSemaphoreui64NVX_ovr_0(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
private static procedure z_SignalSemaphoreui64NVX_ovr_0_anh00010(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
private static procedure z_SignalSemaphoreui64NVX_ovr_0_anh00001(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
private static procedure z_SignalSemaphoreui64NVX_ovr_0_anh00011(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray[0]) else
z_SignalSemaphoreui64NVX_ovr_0_anh00001(signalGpu, fenceObjectCount, semaphoreArray[0], IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_0_anh00010(signalGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray[0]) else
z_SignalSemaphoreui64NVX_ovr_0_anh00011(signalGpu, fenceObjectCount, IntPtr.Zero, IntPtr.Zero);
private static procedure z_SignalSemaphoreui64NVX_ovr_1_anh00010(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_SignalSemaphoreui64NVX_ovr_0_anh00010(signalGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray);
private static procedure z_SignalSemaphoreui64NVX_ovr_2(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
private static procedure z_SignalSemaphoreui64NVX_ovr_2_anh00010(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_2(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_SignalSemaphoreui64NVX_ovr_2_anh00010(signalGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_SignalSemaphoreui64NVX_ovr_0_anh00001(signalGpu, fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64) :=
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr) :=
z_SignalSemaphoreui64NVX_ovr_2(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_SignalSemaphoreui64NVX_ovr_6(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
private static procedure z_SignalSemaphoreui64NVX_ovr_6_anh00001(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_SignalSemaphoreui64NVX_ovr_6(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_SignalSemaphoreui64NVX_ovr_6_anh00001(signalGpu, fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64) :=
z_SignalSemaphoreui64NVX_ovr_6(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_SignalSemaphoreui64NVX_ovr_8(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glSignalSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr) :=
z_SignalSemaphoreui64NVX_ovr_8(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_WaitSemaphoreui64NVX_ovr_0(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
private static procedure z_WaitSemaphoreui64NVX_ovr_0_anh00010(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
private static procedure z_WaitSemaphoreui64NVX_ovr_0_anh00001(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
private static procedure z_WaitSemaphoreui64NVX_ovr_0_anh00011(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray[0]) else
z_WaitSemaphoreui64NVX_ovr_0_anh00001(waitGpu, fenceObjectCount, semaphoreArray[0], IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_0_anh00010(waitGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray[0]) else
z_WaitSemaphoreui64NVX_ovr_0_anh00011(waitGpu, fenceObjectCount, IntPtr.Zero, IntPtr.Zero);
private static procedure z_WaitSemaphoreui64NVX_ovr_1_anh00010(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_WaitSemaphoreui64NVX_ovr_0_anh00010(waitGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray);
private static procedure z_WaitSemaphoreui64NVX_ovr_2(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
private static procedure z_WaitSemaphoreui64NVX_ovr_2_anh00010(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_2(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_WaitSemaphoreui64NVX_ovr_2_anh00010(waitGpu, fenceObjectCount, IntPtr.Zero, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_WaitSemaphoreui64NVX_ovr_0_anh00001(waitGpu, fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64) :=
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr) :=
z_WaitSemaphoreui64NVX_ovr_2(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_WaitSemaphoreui64NVX_ovr_6(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
private static procedure z_WaitSemaphoreui64NVX_ovr_6_anh00001(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_WaitSemaphoreui64NVX_ovr_6(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_WaitSemaphoreui64NVX_ovr_6_anh00001(waitGpu, fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64) :=
z_WaitSemaphoreui64NVX_ovr_6(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_WaitSemaphoreui64NVX_ovr_8(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr) :=
z_WaitSemaphoreui64NVX_ovr_8(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_0_anh0010(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_0_anh0001(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_0_anh0011(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray[0], fenceValueArray[0]) else
z_ClientWaitSemaphoreui64NVX_ovr_0_anh0001(fenceObjectCount, semaphoreArray[0], IntPtr.Zero) else
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_0_anh0010(fenceObjectCount, IntPtr.Zero, fenceValueArray[0]) else
z_ClientWaitSemaphoreui64NVX_ovr_0_anh0011(fenceObjectCount, IntPtr.Zero, IntPtr.Zero);
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_1_anh0010(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_ClientWaitSemaphoreui64NVX_ovr_0_anh0010(fenceObjectCount, IntPtr.Zero, fenceValueArray);
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_2(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_2_anh0010(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr) :=
if (semaphoreArray<>nil) and (semaphoreArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_2(fenceObjectCount, semaphoreArray[0], fenceValueArray) else
z_ClientWaitSemaphoreui64NVX_ovr_2_anh0010(fenceObjectCount, IntPtr.Zero, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_ClientWaitSemaphoreui64NVX_ovr_0_anh0001(fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64) :=
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray, fenceValueArray);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr) :=
z_ClientWaitSemaphoreui64NVX_ovr_2(fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_6(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_6_anh0001(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64) :=
if (fenceValueArray<>nil) and (fenceValueArray.Length<>0) then
z_ClientWaitSemaphoreui64NVX_ovr_6(fenceObjectCount, semaphoreArray, fenceValueArray[0]) else
z_ClientWaitSemaphoreui64NVX_ovr_6_anh0001(fenceObjectCount, semaphoreArray, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64) :=
z_ClientWaitSemaphoreui64NVX_ovr_6(fenceObjectCount, semaphoreArray, fenceValueArray);
private static procedure z_ClientWaitSemaphoreui64NVX_ovr_8(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
external 'opengl32.dll' name 'glClientWaitSemaphoreui64NVX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr) :=
z_ClientWaitSemaphoreui64NVX_ovr_8(fenceObjectCount, semaphoreArray, fenceValueArray);
end;
[PCUNotRestore]
glMemoryAttachmentNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetMemoryObjectDetachedResourcesuivNV_ovr_0(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetMemoryObjectDetachedResourcesuivNV';
private static procedure z_GetMemoryObjectDetachedResourcesuivNV_ovr_0_anh000001(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMemoryObjectDetachedResourcesuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetMemoryObjectDetachedResourcesuivNV_ovr_0(memory, pname, first, count, ¶ms[0]) else
z_GetMemoryObjectDetachedResourcesuivNV_ovr_0_anh000001(memory, pname, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; var ¶ms: UInt32) :=
z_GetMemoryObjectDetachedResourcesuivNV_ovr_0(memory, pname, first, count, ¶ms);
private static procedure z_GetMemoryObjectDetachedResourcesuivNV_ovr_2(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMemoryObjectDetachedResourcesuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: IntPtr) :=
z_GetMemoryObjectDetachedResourcesuivNV_ovr_2(memory, pname, first, count, ¶ms);
private static procedure z_ResetMemoryObjectParameterNV_ovr_0(memory: UInt32; pname: DummyEnum);
external 'opengl32.dll' name 'glResetMemoryObjectParameterNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetMemoryObjectParameterNV(memory: UInt32; pname: DummyEnum) :=
z_ResetMemoryObjectParameterNV_ovr_0(memory, pname);
private static procedure z_TexAttachMemoryNV_ovr_0(target: TextureTarget; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTexAttachMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexAttachMemoryNV(target: TextureTarget; memory: UInt32; offset: UInt64) :=
z_TexAttachMemoryNV_ovr_0(target, memory, offset);
private static procedure z_BufferAttachMemoryNV_ovr_0(target: BufferTargetARB; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glBufferAttachMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAttachMemoryNV(target: BufferTargetARB; memory: UInt32; offset: UInt64) :=
z_BufferAttachMemoryNV_ovr_0(target, memory, offset);
private static procedure z_TextureAttachMemoryNV_ovr_0(texture: UInt32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glTextureAttachMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureAttachMemoryNV(texture: UInt32; memory: UInt32; offset: UInt64) :=
z_TextureAttachMemoryNV_ovr_0(texture, memory, offset);
private static procedure z_NamedBufferAttachMemoryNV_ovr_0(buffer: UInt32; memory: UInt32; offset: UInt64);
external 'opengl32.dll' name 'glNamedBufferAttachMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferAttachMemoryNV(buffer: UInt32; memory: UInt32; offset: UInt64) :=
z_NamedBufferAttachMemoryNV_ovr_0(buffer, memory, offset);
end;
[PCUNotRestore]
glMeshShaderNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawMeshTasksNV_ovr_0(first: UInt32; count: UInt32);
external 'opengl32.dll' name 'glDrawMeshTasksNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshTasksNV(first: UInt32; count: UInt32) :=
z_DrawMeshTasksNV_ovr_0(first, count);
private static procedure z_DrawMeshTasksIndirectNV_ovr_0(indirect: IntPtr);
external 'opengl32.dll' name 'glDrawMeshTasksIndirectNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshTasksIndirectNV(indirect: IntPtr) :=
z_DrawMeshTasksIndirectNV_ovr_0(indirect);
private static procedure z_MultiDrawMeshTasksIndirectNV_ovr_0(indirect: IntPtr; drawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawMeshTasksIndirectNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawMeshTasksIndirectNV(indirect: IntPtr; drawcount: Int32; stride: Int32) :=
z_MultiDrawMeshTasksIndirectNV_ovr_0(indirect, drawcount, stride);
private static procedure z_MultiDrawMeshTasksIndirectCountNV_ovr_0(indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
external 'opengl32.dll' name 'glMultiDrawMeshTasksIndirectCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawMeshTasksIndirectCountNV(indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32) :=
z_MultiDrawMeshTasksIndirectCountNV_ovr_0(indirect, drawcount, maxdrawcount, stride);
end;
[PCUNotRestore]
glOcclusionQueryNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenOcclusionQueriesNV_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glGenOcclusionQueriesNV';
private static procedure z_GenOcclusionQueriesNV_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenOcclusionQueriesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenOcclusionQueriesNV_ovr_0(n, ids[0]) else
z_GenOcclusionQueriesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; var ids: UInt32) :=
z_GenOcclusionQueriesNV_ovr_0(n, ids);
private static procedure z_GenOcclusionQueriesNV_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenOcclusionQueriesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; ids: IntPtr) :=
z_GenOcclusionQueriesNV_ovr_2(n, ids);
private static procedure z_DeleteOcclusionQueriesNV_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glDeleteOcclusionQueriesNV';
private static procedure z_DeleteOcclusionQueriesNV_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteOcclusionQueriesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteOcclusionQueriesNV_ovr_0(n, ids[0]) else
z_DeleteOcclusionQueriesNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; var ids: UInt32) :=
z_DeleteOcclusionQueriesNV_ovr_0(n, ids);
private static procedure z_DeleteOcclusionQueriesNV_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteOcclusionQueriesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; ids: IntPtr) :=
z_DeleteOcclusionQueriesNV_ovr_2(n, ids);
private static function z_IsOcclusionQueryNV_ovr_0(id: UInt32): boolean;
external 'opengl32.dll' name 'glIsOcclusionQueryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsOcclusionQueryNV(id: UInt32): boolean :=
z_IsOcclusionQueryNV_ovr_0(id);
private static procedure z_BeginOcclusionQueryNV_ovr_0(id: UInt32);
external 'opengl32.dll' name 'glBeginOcclusionQueryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginOcclusionQueryNV(id: UInt32) :=
z_BeginOcclusionQueryNV_ovr_0(id);
private static procedure z_EndOcclusionQueryNV_ovr_0;
external 'opengl32.dll' name 'glEndOcclusionQueryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndOcclusionQueryNV :=
z_EndOcclusionQueryNV_ovr_0;
private static procedure z_GetOcclusionQueryivNV_ovr_0(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetOcclusionQueryivNV';
private static procedure z_GetOcclusionQueryivNV_ovr_0_anh0001(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetOcclusionQueryivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetOcclusionQueryivNV_ovr_0(id, pname, ¶ms[0]) else
z_GetOcclusionQueryivNV_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: Int32) :=
z_GetOcclusionQueryivNV_ovr_0(id, pname, ¶ms);
private static procedure z_GetOcclusionQueryivNV_ovr_2(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetOcclusionQueryivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr) :=
z_GetOcclusionQueryivNV_ovr_2(id, pname, ¶ms);
private static procedure z_GetOcclusionQueryuivNV_ovr_0(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetOcclusionQueryuivNV';
private static procedure z_GetOcclusionQueryuivNV_ovr_0_anh0001(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetOcclusionQueryuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetOcclusionQueryuivNV_ovr_0(id, pname, ¶ms[0]) else
z_GetOcclusionQueryuivNV_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: UInt32) :=
z_GetOcclusionQueryuivNV_ovr_0(id, pname, ¶ms);
private static procedure z_GetOcclusionQueryuivNV_ovr_2(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetOcclusionQueryuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr) :=
z_GetOcclusionQueryuivNV_ovr_2(id, pname, ¶ms);
end;
[PCUNotRestore]
glParameterBufferObjectNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ProgramBufferParametersfvNV_ovr_0(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glProgramBufferParametersfvNV';
private static procedure z_ProgramBufferParametersfvNV_ovr_0_anh000001(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramBufferParametersfvNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]) else
z_ProgramBufferParametersfvNV_ovr_0_anh000001(target, bindingIndex, wordIndex, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: single) :=
z_ProgramBufferParametersfvNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
private static procedure z_ProgramBufferParametersfvNV_ovr_2(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramBufferParametersfvNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
private static procedure z_ProgramBufferParametersIivNV_ovr_0(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: Int32);
external 'opengl32.dll' name 'glProgramBufferParametersIivNV';
private static procedure z_ProgramBufferParametersIivNV_ovr_0_anh000001(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramBufferParametersIivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]) else
z_ProgramBufferParametersIivNV_ovr_0_anh000001(target, bindingIndex, wordIndex, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: Int32) :=
z_ProgramBufferParametersIivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
private static procedure z_ProgramBufferParametersIivNV_ovr_2(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersIivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramBufferParametersIivNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
private static procedure z_ProgramBufferParametersIuivNV_ovr_0(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: UInt32);
external 'opengl32.dll' name 'glProgramBufferParametersIuivNV';
private static procedure z_ProgramBufferParametersIuivNV_ovr_0_anh000001(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ProgramBufferParametersIuivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]) else
z_ProgramBufferParametersIuivNV_ovr_0_anh000001(target, bindingIndex, wordIndex, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: UInt32) :=
z_ProgramBufferParametersIuivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
private static procedure z_ProgramBufferParametersIuivNV_ovr_2(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glProgramBufferParametersIuivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr) :=
z_ProgramBufferParametersIuivNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
end;
[PCUNotRestore]
glPathRenderingNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GenPathsNV_ovr_0(range: Int32): UInt32;
external 'opengl32.dll' name 'glGenPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenPathsNV(range: Int32): UInt32 :=
z_GenPathsNV_ovr_0(range);
private static procedure z_DeletePathsNV_ovr_0(path: UInt32; range: Int32);
external 'opengl32.dll' name 'glDeletePathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePathsNV(path: UInt32; range: Int32) :=
z_DeletePathsNV_ovr_0(path, range);
private static function z_IsPathNV_ovr_0(path: UInt32): boolean;
external 'opengl32.dll' name 'glIsPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPathNV(path: UInt32): boolean :=
z_IsPathNV_ovr_0(path);
private static procedure z_PathCommandsNV_ovr_0(path: UInt32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathCommandsNV';
private static procedure z_PathCommandsNV_ovr_0_anh0001000(path: UInt32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; commands: array of Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
if (commands<>nil) and (commands.Length<>0) then
z_PathCommandsNV_ovr_0(path, numCommands, commands[0], numCoords, coordType, coords) else
z_PathCommandsNV_ovr_0_anh0001000(path, numCommands, IntPtr.Zero, numCoords, coordType, coords);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathCommandsNV_ovr_0(path, numCommands, commands, numCoords, coordType, coords);
private static procedure z_PathCommandsNV_ovr_2(path: UInt32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathCommandsNV_ovr_2(path, numCommands, commands, numCoords, coordType, coords);
private static procedure z_PathCoordsNV_ovr_0(path: UInt32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathCoordsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCoordsNV(path: UInt32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathCoordsNV_ovr_0(path, numCoords, coordType, coords);
private static procedure z_PathSubCommandsNV_ovr_0(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathSubCommandsNV';
private static procedure z_PathSubCommandsNV_ovr_0_anh000001000(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathSubCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: array of Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
if (commands<>nil) and (commands.Length<>0) then
z_PathSubCommandsNV_ovr_0(path, commandStart, commandsToDelete, numCommands, commands[0], numCoords, coordType, coords) else
z_PathSubCommandsNV_ovr_0_anh000001000(path, commandStart, commandsToDelete, numCommands, IntPtr.Zero, numCoords, coordType, coords);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathSubCommandsNV_ovr_0(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
private static procedure z_PathSubCommandsNV_ovr_2(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathSubCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathSubCommandsNV_ovr_2(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
private static procedure z_PathSubCoordsNV_ovr_0(path: UInt32; coordStart: Int32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
external 'opengl32.dll' name 'glPathSubCoordsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCoordsNV(path: UInt32; coordStart: Int32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr) :=
z_PathSubCoordsNV_ovr_0(path, coordStart, numCoords, coordType, coords);
private static procedure z_PathStringNV_ovr_0(path: UInt32; format: PathStringFormat; length: Int32; pathString: IntPtr);
external 'opengl32.dll' name 'glPathStringNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStringNV(path: UInt32; format: PathStringFormat; length: Int32; pathString: IntPtr) :=
z_PathStringNV_ovr_0(path, format, length, pathString);
private static procedure z_PathGlyphsNV_ovr_0(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; numGlyphs: Int32; &type: PathElementType; charcodes: IntPtr; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single);
external 'opengl32.dll' name 'glPathGlyphsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathGlyphsNV(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; numGlyphs: Int32; &type: PathElementType; charcodes: IntPtr; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single) :=
z_PathGlyphsNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, &type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
private static procedure z_PathGlyphRangeNV_ovr_0(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyph: UInt32; numGlyphs: Int32; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single);
external 'opengl32.dll' name 'glPathGlyphRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathGlyphRangeNV(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyph: UInt32; numGlyphs: Int32; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single) :=
z_PathGlyphRangeNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
private static procedure z_WeightPathsNV_ovr_0(resultPath: UInt32; numPaths: Int32; var paths: UInt32; var weights: single);
external 'opengl32.dll' name 'glWeightPathsNV';
private static procedure z_WeightPathsNV_ovr_0_anh00010(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single);
external 'opengl32.dll' name 'glWeightPathsNV';
private static procedure z_WeightPathsNV_ovr_0_anh00001(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
private static procedure z_WeightPathsNV_ovr_0_anh00011(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; weights: array of single) :=
if (paths<>nil) and (paths.Length<>0) then
if (weights<>nil) and (weights.Length<>0) then
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths[0], weights[0]) else
z_WeightPathsNV_ovr_0_anh00001(resultPath, numPaths, paths[0], IntPtr.Zero) else
if (weights<>nil) and (weights.Length<>0) then
z_WeightPathsNV_ovr_0_anh00010(resultPath, numPaths, IntPtr.Zero, weights[0]) else
z_WeightPathsNV_ovr_0_anh00011(resultPath, numPaths, IntPtr.Zero, IntPtr.Zero);
private static procedure z_WeightPathsNV_ovr_1_anh00010(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single);
external 'opengl32.dll' name 'glWeightPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; var weights: single) :=
if (paths<>nil) and (paths.Length<>0) then
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths[0], weights) else
z_WeightPathsNV_ovr_0_anh00010(resultPath, numPaths, IntPtr.Zero, weights);
private static procedure z_WeightPathsNV_ovr_2(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
private static procedure z_WeightPathsNV_ovr_2_anh00010(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; weights: IntPtr) :=
if (paths<>nil) and (paths.Length<>0) then
z_WeightPathsNV_ovr_2(resultPath, numPaths, paths[0], weights) else
z_WeightPathsNV_ovr_2_anh00010(resultPath, numPaths, IntPtr.Zero, weights);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: array of single) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths, weights[0]) else
z_WeightPathsNV_ovr_0_anh00001(resultPath, numPaths, paths, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; var weights: single) :=
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths, weights);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: IntPtr) :=
z_WeightPathsNV_ovr_2(resultPath, numPaths, paths, weights);
private static procedure z_WeightPathsNV_ovr_6(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single);
external 'opengl32.dll' name 'glWeightPathsNV';
private static procedure z_WeightPathsNV_ovr_6_anh00001(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: array of single) :=
if (weights<>nil) and (weights.Length<>0) then
z_WeightPathsNV_ovr_6(resultPath, numPaths, paths, weights[0]) else
z_WeightPathsNV_ovr_6_anh00001(resultPath, numPaths, paths, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single) :=
z_WeightPathsNV_ovr_6(resultPath, numPaths, paths, weights);
private static procedure z_WeightPathsNV_ovr_8(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr);
external 'opengl32.dll' name 'glWeightPathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr) :=
z_WeightPathsNV_ovr_8(resultPath, numPaths, paths, weights);
private static procedure z_CopyPathNV_ovr_0(resultPath: UInt32; srcPath: UInt32);
external 'opengl32.dll' name 'glCopyPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyPathNV(resultPath: UInt32; srcPath: UInt32) :=
z_CopyPathNV_ovr_0(resultPath, srcPath);
private static procedure z_InterpolatePathsNV_ovr_0(resultPath: UInt32; pathA: UInt32; pathB: UInt32; weight: single);
external 'opengl32.dll' name 'glInterpolatePathsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InterpolatePathsNV(resultPath: UInt32; pathA: UInt32; pathB: UInt32; weight: single) :=
z_InterpolatePathsNV_ovr_0(resultPath, pathA, pathB, weight);
private static procedure z_TransformPathNV_ovr_0(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; var transformValues: single);
external 'opengl32.dll' name 'glTransformPathNV';
private static procedure z_TransformPathNV_ovr_0_anh00001(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glTransformPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_TransformPathNV_ovr_0(resultPath, srcPath, transformType, transformValues[0]) else
z_TransformPathNV_ovr_0_anh00001(resultPath, srcPath, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; var transformValues: single) :=
z_TransformPathNV_ovr_0(resultPath, srcPath, transformType, transformValues);
private static procedure z_TransformPathNV_ovr_2(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glTransformPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: IntPtr) :=
z_TransformPathNV_ovr_2(resultPath, srcPath, transformType, transformValues);
private static procedure z_PathParameterivNV_ovr_0(path: UInt32; pname: PathParameter; var value: Int32);
external 'opengl32.dll' name 'glPathParameterivNV';
private static procedure z_PathParameterivNV_ovr_0_anh0001(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glPathParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_PathParameterivNV_ovr_0(path, pname, value[0]) else
z_PathParameterivNV_ovr_0_anh0001(path, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; var value: Int32) :=
z_PathParameterivNV_ovr_0(path, pname, value);
private static procedure z_PathParameterivNV_ovr_2(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glPathParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; value: IntPtr) :=
z_PathParameterivNV_ovr_2(path, pname, value);
private static procedure z_PathParameteriNV_ovr_0(path: UInt32; pname: PathParameter; value: Int32);
external 'opengl32.dll' name 'glPathParameteriNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameteriNV(path: UInt32; pname: PathParameter; value: Int32) :=
z_PathParameteriNV_ovr_0(path, pname, value);
private static procedure z_PathParameterfvNV_ovr_0(path: UInt32; pname: PathParameter; var value: single);
external 'opengl32.dll' name 'glPathParameterfvNV';
private static procedure z_PathParameterfvNV_ovr_0_anh0001(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glPathParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_PathParameterfvNV_ovr_0(path, pname, value[0]) else
z_PathParameterfvNV_ovr_0_anh0001(path, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; var value: single) :=
z_PathParameterfvNV_ovr_0(path, pname, value);
private static procedure z_PathParameterfvNV_ovr_2(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glPathParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; value: IntPtr) :=
z_PathParameterfvNV_ovr_2(path, pname, value);
private static procedure z_PathParameterfNV_ovr_0(path: UInt32; pname: PathParameter; value: single);
external 'opengl32.dll' name 'glPathParameterfNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfNV(path: UInt32; pname: PathParameter; value: single) :=
z_PathParameterfNV_ovr_0(path, pname, value);
private static procedure z_PathDashArrayNV_ovr_0(path: UInt32; dashCount: Int32; var dashArray: single);
external 'opengl32.dll' name 'glPathDashArrayNV';
private static procedure z_PathDashArrayNV_ovr_0_anh0001(path: UInt32; dashCount: Int32; dashArray: IntPtr);
external 'opengl32.dll' name 'glPathDashArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; dashArray: array of single) :=
if (dashArray<>nil) and (dashArray.Length<>0) then
z_PathDashArrayNV_ovr_0(path, dashCount, dashArray[0]) else
z_PathDashArrayNV_ovr_0_anh0001(path, dashCount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; var dashArray: single) :=
z_PathDashArrayNV_ovr_0(path, dashCount, dashArray);
private static procedure z_PathDashArrayNV_ovr_2(path: UInt32; dashCount: Int32; dashArray: IntPtr);
external 'opengl32.dll' name 'glPathDashArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; dashArray: IntPtr) :=
z_PathDashArrayNV_ovr_2(path, dashCount, dashArray);
private static procedure z_PathStencilFuncNV_ovr_0(func: StencilFunction; ref: Int32; mask: UInt32);
external 'opengl32.dll' name 'glPathStencilFuncNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStencilFuncNV(func: StencilFunction; ref: Int32; mask: UInt32) :=
z_PathStencilFuncNV_ovr_0(func, ref, mask);
private static procedure z_PathStencilDepthOffsetNV_ovr_0(factor: single; units: single);
external 'opengl32.dll' name 'glPathStencilDepthOffsetNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStencilDepthOffsetNV(factor: single; units: single) :=
z_PathStencilDepthOffsetNV_ovr_0(factor, units);
private static procedure z_StencilFillPathNV_ovr_0(path: UInt32; fillMode: PathFillMode; mask: UInt32);
external 'opengl32.dll' name 'glStencilFillPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathNV(path: UInt32; fillMode: PathFillMode; mask: UInt32) :=
z_StencilFillPathNV_ovr_0(path, fillMode, mask);
private static procedure z_StencilStrokePathNV_ovr_0(path: UInt32; reference: Int32; mask: UInt32);
external 'opengl32.dll' name 'glStencilStrokePathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathNV(path: UInt32; reference: Int32; mask: UInt32) :=
z_StencilStrokePathNV_ovr_0(path, reference, mask);
private static procedure z_StencilFillPathInstancedNV_ovr_0(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; var transformValues: single);
external 'opengl32.dll' name 'glStencilFillPathInstancedNV';
private static procedure z_StencilFillPathInstancedNV_ovr_0_anh000000001(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_StencilFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues[0]) else
z_StencilFillPathInstancedNV_ovr_0_anh000000001(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; var transformValues: single) :=
z_StencilFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
private static procedure z_StencilFillPathInstancedNV_ovr_2(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr) :=
z_StencilFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
private static procedure z_StencilStrokePathInstancedNV_ovr_0(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; var transformValues: single);
external 'opengl32.dll' name 'glStencilStrokePathInstancedNV';
private static procedure z_StencilStrokePathInstancedNV_ovr_0_anh000000001(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_StencilStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues[0]) else
z_StencilStrokePathInstancedNV_ovr_0_anh000000001(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; var transformValues: single) :=
z_StencilStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
private static procedure z_StencilStrokePathInstancedNV_ovr_2(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr) :=
z_StencilStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
private static procedure z_PathCoverDepthFuncNV_ovr_0(func: DepthFunction);
external 'opengl32.dll' name 'glPathCoverDepthFuncNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCoverDepthFuncNV(func: DepthFunction) :=
z_PathCoverDepthFuncNV_ovr_0(func);
private static procedure z_CoverFillPathNV_ovr_0(path: UInt32; coverMode: PathCoverMode);
external 'opengl32.dll' name 'glCoverFillPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathNV(path: UInt32; coverMode: PathCoverMode) :=
z_CoverFillPathNV_ovr_0(path, coverMode);
private static procedure z_CoverStrokePathNV_ovr_0(path: UInt32; coverMode: PathCoverMode);
external 'opengl32.dll' name 'glCoverStrokePathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathNV(path: UInt32; coverMode: PathCoverMode) :=
z_CoverStrokePathNV_ovr_0(path, coverMode);
private static procedure z_CoverFillPathInstancedNV_ovr_0(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single);
external 'opengl32.dll' name 'glCoverFillPathInstancedNV';
private static procedure z_CoverFillPathInstancedNV_ovr_0_anh00000001(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glCoverFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_CoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues[0]) else
z_CoverFillPathInstancedNV_ovr_0_anh00000001(numPaths, pathNameType, paths, pathBase, coverMode, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single) :=
z_CoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
private static procedure z_CoverFillPathInstancedNV_ovr_2(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glCoverFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr) :=
z_CoverFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
private static procedure z_CoverStrokePathInstancedNV_ovr_0(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single);
external 'opengl32.dll' name 'glCoverStrokePathInstancedNV';
private static procedure z_CoverStrokePathInstancedNV_ovr_0_anh00000001(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glCoverStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_CoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues[0]) else
z_CoverStrokePathInstancedNV_ovr_0_anh00000001(numPaths, pathNameType, paths, pathBase, coverMode, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single) :=
z_CoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
private static procedure z_CoverStrokePathInstancedNV_ovr_2(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
external 'opengl32.dll' name 'glCoverStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr) :=
z_CoverStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
private static procedure z_GetPathParameterivNV_ovr_0(path: UInt32; pname: PathParameter; var value: Int32);
external 'opengl32.dll' name 'glGetPathParameterivNV';
private static procedure z_GetPathParameterivNV_ovr_0_anh0001(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glGetPathParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathParameterivNV_ovr_0(path, pname, value[0]) else
z_GetPathParameterivNV_ovr_0_anh0001(path, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; var value: Int32) :=
z_GetPathParameterivNV_ovr_0(path, pname, value);
private static procedure z_GetPathParameterivNV_ovr_2(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glGetPathParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; value: IntPtr) :=
z_GetPathParameterivNV_ovr_2(path, pname, value);
private static procedure z_GetPathParameterfvNV_ovr_0(path: UInt32; pname: PathParameter; var value: single);
external 'opengl32.dll' name 'glGetPathParameterfvNV';
private static procedure z_GetPathParameterfvNV_ovr_0_anh0001(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glGetPathParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathParameterfvNV_ovr_0(path, pname, value[0]) else
z_GetPathParameterfvNV_ovr_0_anh0001(path, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; var value: single) :=
z_GetPathParameterfvNV_ovr_0(path, pname, value);
private static procedure z_GetPathParameterfvNV_ovr_2(path: UInt32; pname: PathParameter; value: IntPtr);
external 'opengl32.dll' name 'glGetPathParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; value: IntPtr) :=
z_GetPathParameterfvNV_ovr_2(path, pname, value);
private static procedure z_GetPathCommandsNV_ovr_0(path: UInt32; var commands: Byte);
external 'opengl32.dll' name 'glGetPathCommandsNV';
private static procedure z_GetPathCommandsNV_ovr_0_anh001(path: UInt32; commands: IntPtr);
external 'opengl32.dll' name 'glGetPathCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; commands: array of Byte) :=
if (commands<>nil) and (commands.Length<>0) then
z_GetPathCommandsNV_ovr_0(path, commands[0]) else
z_GetPathCommandsNV_ovr_0_anh001(path, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; var commands: Byte) :=
z_GetPathCommandsNV_ovr_0(path, commands);
private static procedure z_GetPathCommandsNV_ovr_2(path: UInt32; commands: IntPtr);
external 'opengl32.dll' name 'glGetPathCommandsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; commands: IntPtr) :=
z_GetPathCommandsNV_ovr_2(path, commands);
private static procedure z_GetPathCoordsNV_ovr_0(path: UInt32; var coords: single);
external 'opengl32.dll' name 'glGetPathCoordsNV';
private static procedure z_GetPathCoordsNV_ovr_0_anh001(path: UInt32; coords: IntPtr);
external 'opengl32.dll' name 'glGetPathCoordsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; coords: array of single) :=
if (coords<>nil) and (coords.Length<>0) then
z_GetPathCoordsNV_ovr_0(path, coords[0]) else
z_GetPathCoordsNV_ovr_0_anh001(path, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; var coords: single) :=
z_GetPathCoordsNV_ovr_0(path, coords);
private static procedure z_GetPathCoordsNV_ovr_2(path: UInt32; coords: IntPtr);
external 'opengl32.dll' name 'glGetPathCoordsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; coords: IntPtr) :=
z_GetPathCoordsNV_ovr_2(path, coords);
private static procedure z_GetPathDashArrayNV_ovr_0(path: UInt32; var dashArray: single);
external 'opengl32.dll' name 'glGetPathDashArrayNV';
private static procedure z_GetPathDashArrayNV_ovr_0_anh001(path: UInt32; dashArray: IntPtr);
external 'opengl32.dll' name 'glGetPathDashArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; dashArray: array of single) :=
if (dashArray<>nil) and (dashArray.Length<>0) then
z_GetPathDashArrayNV_ovr_0(path, dashArray[0]) else
z_GetPathDashArrayNV_ovr_0_anh001(path, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; var dashArray: single) :=
z_GetPathDashArrayNV_ovr_0(path, dashArray);
private static procedure z_GetPathDashArrayNV_ovr_2(path: UInt32; dashArray: IntPtr);
external 'opengl32.dll' name 'glGetPathDashArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; dashArray: IntPtr) :=
z_GetPathDashArrayNV_ovr_2(path, dashArray);
private static procedure z_GetPathMetricsNV_ovr_0(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; var metrics: single);
external 'opengl32.dll' name 'glGetPathMetricsNV';
private static procedure z_GetPathMetricsNV_ovr_0_anh00000001(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: IntPtr);
external 'opengl32.dll' name 'glGetPathMetricsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: array of single) :=
if (metrics<>nil) and (metrics.Length<>0) then
z_GetPathMetricsNV_ovr_0(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics[0]) else
z_GetPathMetricsNV_ovr_0_anh00000001(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; var metrics: single) :=
z_GetPathMetricsNV_ovr_0(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
private static procedure z_GetPathMetricsNV_ovr_2(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: IntPtr);
external 'opengl32.dll' name 'glGetPathMetricsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: IntPtr) :=
z_GetPathMetricsNV_ovr_2(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
private static procedure z_GetPathMetricRangeNV_ovr_0(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; var metrics: single);
external 'opengl32.dll' name 'glGetPathMetricRangeNV';
private static procedure z_GetPathMetricRangeNV_ovr_0_anh000001(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: IntPtr);
external 'opengl32.dll' name 'glGetPathMetricRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: array of single) :=
if (metrics<>nil) and (metrics.Length<>0) then
z_GetPathMetricRangeNV_ovr_0(metricQueryMask, firstPathName, numPaths, stride, metrics[0]) else
z_GetPathMetricRangeNV_ovr_0_anh000001(metricQueryMask, firstPathName, numPaths, stride, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; var metrics: single) :=
z_GetPathMetricRangeNV_ovr_0(metricQueryMask, firstPathName, numPaths, stride, metrics);
private static procedure z_GetPathMetricRangeNV_ovr_2(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: IntPtr);
external 'opengl32.dll' name 'glGetPathMetricRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: IntPtr) :=
z_GetPathMetricRangeNV_ovr_2(metricQueryMask, firstPathName, numPaths, stride, metrics);
private static procedure z_GetPathSpacingNV_ovr_0(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; var returnedSpacing: single);
external 'opengl32.dll' name 'glGetPathSpacingNV';
private static procedure z_GetPathSpacingNV_ovr_0_anh0000000001(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: IntPtr);
external 'opengl32.dll' name 'glGetPathSpacingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathSpacingNV(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: array of single) :=
if (returnedSpacing<>nil) and (returnedSpacing.Length<>0) then
z_GetPathSpacingNV_ovr_0(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing[0]) else
z_GetPathSpacingNV_ovr_0_anh0000000001(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathSpacingNV(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; var returnedSpacing: single) :=
z_GetPathSpacingNV_ovr_0(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
private static procedure z_GetPathSpacingNV_ovr_2(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: IntPtr);
external 'opengl32.dll' name 'glGetPathSpacingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathSpacingNV(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: IntPtr) :=
z_GetPathSpacingNV_ovr_2(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
private static function z_IsPointInFillPathNV_ovr_0(path: UInt32; mask: UInt32; x: single; y: single): boolean;
external 'opengl32.dll' name 'glIsPointInFillPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPointInFillPathNV(path: UInt32; mask: UInt32; x: single; y: single): boolean :=
z_IsPointInFillPathNV_ovr_0(path, mask, x, y);
private static function z_IsPointInStrokePathNV_ovr_0(path: UInt32; x: single; y: single): boolean;
external 'opengl32.dll' name 'glIsPointInStrokePathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPointInStrokePathNV(path: UInt32; x: single; y: single): boolean :=
z_IsPointInStrokePathNV_ovr_0(path, x, y);
private static function z_GetPathLengthNV_ovr_0(path: UInt32; startSegment: Int32; numSegments: Int32): single;
external 'opengl32.dll' name 'glGetPathLengthNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetPathLengthNV(path: UInt32; startSegment: Int32; numSegments: Int32): single :=
z_GetPathLengthNV_ovr_0(path, startSegment, numSegments);
private static function z_PointAlongPathNV_ovr_0(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000000111(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_0_anh000001111(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: array of single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x[0], y[0], IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000011(path, startSegment, numSegments, distance, x[0], y[0], IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000101(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000110(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000111(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) else
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001011(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001101(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001110(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001111(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_1_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_1_anh000001110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: array of single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x[0], y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000110(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, IntPtr.Zero, tangentY) else
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000001110(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_2(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_2_anh000001110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000010(path, startSegment, numSegments, distance, x[0], y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000110(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, IntPtr.Zero, tangentY) else
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000001110(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_3_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_3_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_3_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_3_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_3_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_3_anh000001101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; var tangentX: single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x[0], y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000101(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, IntPtr.Zero) else
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001101(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_4_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_4_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_4_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; var tangentX: single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY) else
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_0_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_5_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_5_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_5_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; var tangentX: single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_2_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY) else
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_2_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_6(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_6_anh000001101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000001(path, startSegment, numSegments, distance, x[0], y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000101(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, IntPtr.Zero) else
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000001101(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_7_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_7_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_7_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: IntPtr; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_6_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY) else
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_6_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_8(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_8_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_8_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_8_anh000001100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: array of single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_8_anh000000100(path, startSegment, numSegments, distance, x[0], IntPtr.Zero, tangentX, tangentY) else
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_8_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_8_anh000001100(path, startSegment, numSegments, distance, IntPtr.Zero, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_9_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_9_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_9_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_9_anh000001011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: array of single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000011(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001011(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_10_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_10_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: array of single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_11_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_11_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_12_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_12_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; var tangentX: single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_13_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; var tangentX: single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_0_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_14_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; var tangentX: single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_2_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_15_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_15_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_16_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: IntPtr; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_6_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_17_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_8_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_18(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000000011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_18_anh000001011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: array of single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000011(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000001011(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_19_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_19_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_19_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: array of single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_18_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_18_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_20(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_20_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_20_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_20_anh000001010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: array of single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_20_anh000000010(path, startSegment, numSegments, distance, x[0], y, IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_20_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_20_anh000001010(path, startSegment, numSegments, distance, IntPtr.Zero, y, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_21_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_21_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; var tangentX: single; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_22_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; var tangentX: single; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_18_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_23_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_20_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_24(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_24_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_24_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_24_anh000001001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: IntPtr; tangentY: array of single): boolean :=
if (x<>nil) and (x.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_24_anh000000001(path, startSegment, numSegments, distance, x[0], y, tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_24_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_24_anh000001001(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_25_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_24_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_26(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_26_anh000001000(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: array of single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean :=
if (x<>nil) and (x.Length<>0) then
z_PointAlongPathNV_ovr_26(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY) else
z_PointAlongPathNV_ovr_26_anh000001000(path, startSegment, numSegments, distance, IntPtr.Zero, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: array of single; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000011(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000111(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: array of single; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; var tangentX: single; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; var tangentX: single; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_0_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; var tangentX: single; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_2_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: IntPtr; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_6_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: array of single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_8_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: array of single; tangentY: array of single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000011(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: array of single; var tangentY: single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_0_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_2_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_0_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_6_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: array of single; tangentY: array of single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000011(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: array of single; var tangentY: single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_18_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: array of single; tangentY: IntPtr): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_20_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_18_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_24_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_26(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_54(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_54_anh000000111(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: array of single; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000011(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, IntPtr.Zero) else
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000111(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_55_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_55_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_55_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: array of single; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_54_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_54_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_56(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_56_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_56_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_56_anh000000110(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_56_anh000000010(path, startSegment, numSegments, distance, x, y[0], IntPtr.Zero, tangentY) else
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_56_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_56_anh000000110(path, startSegment, numSegments, distance, x, IntPtr.Zero, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_57_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_57_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; var tangentX: single; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_58_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; var tangentX: single; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_54_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_59_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; var tangentX: single; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_56_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_60(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_60_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_60_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_60_anh000000101(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (y<>nil) and (y.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_60_anh000000001(path, startSegment, numSegments, distance, x, y[0], tangentX, IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_60_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_60_anh000000101(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_61_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: IntPtr; var tangentY: single): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_60_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_62(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_62_anh000000100(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: array of single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
if (y<>nil) and (y.Length<>0) then
z_PointAlongPathNV_ovr_62(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY) else
z_PointAlongPathNV_ovr_62_anh000000100(path, startSegment, numSegments, distance, x, IntPtr.Zero, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: array of single; tangentY: array of single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000011(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: array of single; var tangentY: single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_54_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: array of single; tangentY: IntPtr): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_56_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_54_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_60_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_62(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_72(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_72_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_72_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_72_anh000000011(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: array of single; tangentY: array of single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]) else
z_PointAlongPathNV_ovr_72_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX[0], IntPtr.Zero) else
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_72_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY[0]) else
z_PointAlongPathNV_ovr_72_anh000000011(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, IntPtr.Zero);
private static function z_PointAlongPathNV_ovr_73_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: array of single; var tangentY: single): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_72_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
private static function z_PointAlongPathNV_ovr_74(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_74_anh000000010(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: array of single; tangentY: IntPtr): boolean :=
if (tangentX<>nil) and (tangentX.Length<>0) then
z_PointAlongPathNV_ovr_74(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY) else
z_PointAlongPathNV_ovr_74_anh000000010(path, startSegment, numSegments, distance, x, y, IntPtr.Zero, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_72_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_74(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_78(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
private static function z_PointAlongPathNV_ovr_78_anh000000001(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: array of single): boolean :=
if (tangentY<>nil) and (tangentY.Length<>0) then
z_PointAlongPathNV_ovr_78(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]) else
z_PointAlongPathNV_ovr_78_anh000000001(path, startSegment, numSegments, distance, x, y, tangentX, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean :=
z_PointAlongPathNV_ovr_78(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
private static function z_PointAlongPathNV_ovr_80(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
external 'opengl32.dll' name 'glPointAlongPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean :=
z_PointAlongPathNV_ovr_80(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
private static procedure z_MatrixLoad3x2fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixLoad3x2fNV';
private static procedure z_MatrixLoad3x2fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoad3x2fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoad3x2fNV_ovr_0(matrixMode, m[0]) else
z_MatrixLoad3x2fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixLoad3x2fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixLoad3x2fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoad3x2fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixLoad3x2fNV_ovr_2(matrixMode, m);
private static procedure z_MatrixLoad3x3fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixLoad3x3fNV';
private static procedure z_MatrixLoad3x3fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoad3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoad3x3fNV_ovr_0(matrixMode, m[0]) else
z_MatrixLoad3x3fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixLoad3x3fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixLoad3x3fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoad3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixLoad3x3fNV_ovr_2(matrixMode, m);
private static procedure z_MatrixLoadTranspose3x3fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixLoadTranspose3x3fNV';
private static procedure z_MatrixLoadTranspose3x3fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTranspose3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadTranspose3x3fNV_ovr_0(matrixMode, m[0]) else
z_MatrixLoadTranspose3x3fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixLoadTranspose3x3fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixLoadTranspose3x3fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTranspose3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixLoadTranspose3x3fNV_ovr_2(matrixMode, m);
private static procedure z_MatrixMult3x2fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixMult3x2fNV';
private static procedure z_MatrixMult3x2fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMult3x2fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMult3x2fNV_ovr_0(matrixMode, m[0]) else
z_MatrixMult3x2fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixMult3x2fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixMult3x2fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMult3x2fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixMult3x2fNV_ovr_2(matrixMode, m);
private static procedure z_MatrixMult3x3fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixMult3x3fNV';
private static procedure z_MatrixMult3x3fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMult3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMult3x3fNV_ovr_0(matrixMode, m[0]) else
z_MatrixMult3x3fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixMult3x3fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixMult3x3fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMult3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixMult3x3fNV_ovr_2(matrixMode, m);
private static procedure z_MatrixMultTranspose3x3fNV_ovr_0(matrixMode: DummyEnum; var m: single);
external 'opengl32.dll' name 'glMatrixMultTranspose3x3fNV';
private static procedure z_MatrixMultTranspose3x3fNV_ovr_0_anh001(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTranspose3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultTranspose3x3fNV_ovr_0(matrixMode, m[0]) else
z_MatrixMultTranspose3x3fNV_ovr_0_anh001(matrixMode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; var m: single) :=
z_MatrixMultTranspose3x3fNV_ovr_0(matrixMode, m);
private static procedure z_MatrixMultTranspose3x3fNV_ovr_2(matrixMode: DummyEnum; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTranspose3x3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; m: IntPtr) :=
z_MatrixMultTranspose3x3fNV_ovr_2(matrixMode, m);
private static procedure z_StencilThenCoverFillPathNV_ovr_0(path: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum);
external 'opengl32.dll' name 'glStencilThenCoverFillPathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathNV(path: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum) :=
z_StencilThenCoverFillPathNV_ovr_0(path, fillMode, mask, coverMode);
private static procedure z_StencilThenCoverStrokePathNV_ovr_0(path: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum);
external 'opengl32.dll' name 'glStencilThenCoverStrokePathNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathNV(path: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum) :=
z_StencilThenCoverStrokePathNV_ovr_0(path, reference, mask, coverMode);
private static procedure z_StencilThenCoverFillPathInstancedNV_ovr_0(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single);
external 'opengl32.dll' name 'glStencilThenCoverFillPathInstancedNV';
private static procedure z_StencilThenCoverFillPathInstancedNV_ovr_0_anh0000000001(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilThenCoverFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_StencilThenCoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues[0]) else
z_StencilThenCoverFillPathInstancedNV_ovr_0_anh0000000001(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single) :=
z_StencilThenCoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
private static procedure z_StencilThenCoverFillPathInstancedNV_ovr_2(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilThenCoverFillPathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr) :=
z_StencilThenCoverFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
private static procedure z_StencilThenCoverStrokePathInstancedNV_ovr_0(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single);
external 'opengl32.dll' name 'glStencilThenCoverStrokePathInstancedNV';
private static procedure z_StencilThenCoverStrokePathInstancedNV_ovr_0_anh0000000001(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilThenCoverStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: array of single) :=
if (transformValues<>nil) and (transformValues.Length<>0) then
z_StencilThenCoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues[0]) else
z_StencilThenCoverStrokePathInstancedNV_ovr_0_anh0000000001(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single) :=
z_StencilThenCoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
private static procedure z_StencilThenCoverStrokePathInstancedNV_ovr_2(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
external 'opengl32.dll' name 'glStencilThenCoverStrokePathInstancedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr) :=
z_StencilThenCoverStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
private static function z_PathGlyphIndexRangeNV_ovr_0(fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; pathParameterTemplate: UInt32; emScale: single; baseAndCount: UInt32): DummyEnum;
external 'opengl32.dll' name 'glPathGlyphIndexRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PathGlyphIndexRangeNV(fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; pathParameterTemplate: UInt32; emScale: single; baseAndCount: UInt32): DummyEnum :=
z_PathGlyphIndexRangeNV_ovr_0(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
private static function z_PathGlyphIndexArrayNV_ovr_0(firstPathName: UInt32; fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum;
external 'opengl32.dll' name 'glPathGlyphIndexArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PathGlyphIndexArrayNV(firstPathName: UInt32; fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum :=
z_PathGlyphIndexArrayNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
private static function z_PathMemoryGlyphIndexArrayNV_ovr_0(firstPathName: UInt32; fontTarget: DummyEnum; fontSize: IntPtr; fontData: IntPtr; faceIndex: Int32; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum;
external 'opengl32.dll' name 'glPathMemoryGlyphIndexArrayNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PathMemoryGlyphIndexArrayNV(firstPathName: UInt32; fontTarget: DummyEnum; fontSize: IntPtr; fontData: IntPtr; faceIndex: Int32; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum :=
z_PathMemoryGlyphIndexArrayNV_ovr_0(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
private static procedure z_ProgramPathFragmentInputGenNV_ovr_0(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; var coeffs: single);
external 'opengl32.dll' name 'glProgramPathFragmentInputGenNV';
private static procedure z_ProgramPathFragmentInputGenNV_ovr_0_anh000001(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: IntPtr);
external 'opengl32.dll' name 'glProgramPathFragmentInputGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: array of single) :=
if (coeffs<>nil) and (coeffs.Length<>0) then
z_ProgramPathFragmentInputGenNV_ovr_0(&program, location, genMode, components, coeffs[0]) else
z_ProgramPathFragmentInputGenNV_ovr_0_anh000001(&program, location, genMode, components, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; var coeffs: single) :=
z_ProgramPathFragmentInputGenNV_ovr_0(&program, location, genMode, components, coeffs);
private static procedure z_ProgramPathFragmentInputGenNV_ovr_2(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: IntPtr);
external 'opengl32.dll' name 'glProgramPathFragmentInputGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: IntPtr) :=
z_ProgramPathFragmentInputGenNV_ovr_2(&program, location, genMode, components, coeffs);
private static procedure z_GetProgramResourcefvNV_ovr_0(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000000011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_0_anh000001011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: array of Int32; ¶ms: array of single) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000011(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, IntPtr.Zero) else
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000001011(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramResourcefvNV_ovr_1_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_1_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_1_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: array of Int32; var ¶ms: single) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_0_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_0_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_2(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_2_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_2_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_2_anh000001010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_2_anh000000010(&program, _programInterface, index, propCount, props[0], count, IntPtr.Zero, ¶ms) else
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_2_anh000001010(&program, _programInterface, index, propCount, IntPtr.Zero, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_3_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_3_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; var length: Int32; ¶ms: array of single) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private static procedure z_GetProgramResourcefvNV_ovr_4_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; var length: Int32; var ¶ms: single) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourcefvNV_ovr_0_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_5_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourcefvNV_ovr_2_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_6(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_6_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_6_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_6_anh000001001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: IntPtr; ¶ms: array of single) :=
if (props<>nil) and (props.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_6_anh000000001(&program, _programInterface, index, propCount, props[0], count, length, IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_6_anh000001001(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, IntPtr.Zero);
private static procedure z_GetProgramResourcefvNV_ovr_7_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: IntPtr; var ¶ms: single) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourcefvNV_ovr_6_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_8(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_8_anh000001000(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
if (props<>nil) and (props.Length<>0) then
z_GetProgramResourcefvNV_ovr_8(&program, _programInterface, index, propCount, props[0], count, length, ¶ms) else
z_GetProgramResourcefvNV_ovr_8_anh000001000(&program, _programInterface, index, propCount, IntPtr.Zero, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: array of Int32; ¶ms: array of single) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: array of Int32; var ¶ms: single) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_0_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_2_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_0_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; var ¶ms: single) :=
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_6_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single) :=
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourcefvNV_ovr_8(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_18(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_18_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_18_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_18_anh000000011(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: array of single) :=
if (length<>nil) and (length.Length<>0) then
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length[0], IntPtr.Zero) else
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_18_anh000000011(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_GetProgramResourcefvNV_ovr_19_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; var ¶ms: single) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_18_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_20(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_20_anh000000010(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetProgramResourcefvNV_ovr_20(&program, _programInterface, index, propCount, props, count, length[0], ¶ms) else
z_GetProgramResourcefvNV_ovr_20_anh000000010(&program, _programInterface, index, propCount, props, count, IntPtr.Zero, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_18_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single) :=
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr) :=
z_GetProgramResourcefvNV_ovr_20(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_24(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
private static procedure z_GetProgramResourcefvNV_ovr_24_anh000000001(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramResourcefvNV_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]) else
z_GetProgramResourcefvNV_ovr_24_anh000000001(&program, _programInterface, index, propCount, props, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single) :=
z_GetProgramResourcefvNV_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_GetProgramResourcefvNV_ovr_26(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramResourcefvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr) :=
z_GetProgramResourcefvNV_ovr_26(&program, _programInterface, index, propCount, props, count, length, ¶ms);
private static procedure z_PathColorGenNV_ovr_0(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; var coeffs: single);
external 'opengl32.dll' name 'glPathColorGenNV';
private static procedure z_PathColorGenNV_ovr_0_anh00001(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: IntPtr);
external 'opengl32.dll' name 'glPathColorGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: array of single) :=
if (coeffs<>nil) and (coeffs.Length<>0) then
z_PathColorGenNV_ovr_0(color, genMode, colorFormat, coeffs[0]) else
z_PathColorGenNV_ovr_0_anh00001(color, genMode, colorFormat, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; var coeffs: single) :=
z_PathColorGenNV_ovr_0(color, genMode, colorFormat, coeffs);
private static procedure z_PathColorGenNV_ovr_2(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: IntPtr);
external 'opengl32.dll' name 'glPathColorGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: IntPtr) :=
z_PathColorGenNV_ovr_2(color, genMode, colorFormat, coeffs);
private static procedure z_PathTexGenNV_ovr_0(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; var coeffs: single);
external 'opengl32.dll' name 'glPathTexGenNV';
private static procedure z_PathTexGenNV_ovr_0_anh00001(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: IntPtr);
external 'opengl32.dll' name 'glPathTexGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: array of single) :=
if (coeffs<>nil) and (coeffs.Length<>0) then
z_PathTexGenNV_ovr_0(texCoordSet, genMode, components, coeffs[0]) else
z_PathTexGenNV_ovr_0_anh00001(texCoordSet, genMode, components, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; var coeffs: single) :=
z_PathTexGenNV_ovr_0(texCoordSet, genMode, components, coeffs);
private static procedure z_PathTexGenNV_ovr_2(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: IntPtr);
external 'opengl32.dll' name 'glPathTexGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: IntPtr) :=
z_PathTexGenNV_ovr_2(texCoordSet, genMode, components, coeffs);
private static procedure z_PathFogGenNV_ovr_0(genMode: PathGenMode);
external 'opengl32.dll' name 'glPathFogGenNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathFogGenNV(genMode: PathGenMode) :=
z_PathFogGenNV_ovr_0(genMode);
private static procedure z_GetPathColorGenivNV_ovr_0(color: PathColor; pname: PathGenMode; var value: Int32);
external 'opengl32.dll' name 'glGetPathColorGenivNV';
private static procedure z_GetPathColorGenivNV_ovr_0_anh0001(color: PathColor; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathColorGenivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathColorGenivNV_ovr_0(color, pname, value[0]) else
z_GetPathColorGenivNV_ovr_0_anh0001(color, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; var value: Int32) :=
z_GetPathColorGenivNV_ovr_0(color, pname, value);
private static procedure z_GetPathColorGenivNV_ovr_2(color: PathColor; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathColorGenivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; value: IntPtr) :=
z_GetPathColorGenivNV_ovr_2(color, pname, value);
private static procedure z_GetPathColorGenfvNV_ovr_0(color: PathColor; pname: PathGenMode; var value: single);
external 'opengl32.dll' name 'glGetPathColorGenfvNV';
private static procedure z_GetPathColorGenfvNV_ovr_0_anh0001(color: PathColor; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathColorGenfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathColorGenfvNV_ovr_0(color, pname, value[0]) else
z_GetPathColorGenfvNV_ovr_0_anh0001(color, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; var value: single) :=
z_GetPathColorGenfvNV_ovr_0(color, pname, value);
private static procedure z_GetPathColorGenfvNV_ovr_2(color: PathColor; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathColorGenfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; value: IntPtr) :=
z_GetPathColorGenfvNV_ovr_2(color, pname, value);
private static procedure z_GetPathTexGenivNV_ovr_0(texCoordSet: TextureUnit; pname: PathGenMode; var value: Int32);
external 'opengl32.dll' name 'glGetPathTexGenivNV';
private static procedure z_GetPathTexGenivNV_ovr_0_anh0001(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathTexGenivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; value: array of Int32) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathTexGenivNV_ovr_0(texCoordSet, pname, value[0]) else
z_GetPathTexGenivNV_ovr_0_anh0001(texCoordSet, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; var value: Int32) :=
z_GetPathTexGenivNV_ovr_0(texCoordSet, pname, value);
private static procedure z_GetPathTexGenivNV_ovr_2(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathTexGenivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr) :=
z_GetPathTexGenivNV_ovr_2(texCoordSet, pname, value);
private static procedure z_GetPathTexGenfvNV_ovr_0(texCoordSet: TextureUnit; pname: PathGenMode; var value: single);
external 'opengl32.dll' name 'glGetPathTexGenfvNV';
private static procedure z_GetPathTexGenfvNV_ovr_0_anh0001(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathTexGenfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; value: array of single) :=
if (value<>nil) and (value.Length<>0) then
z_GetPathTexGenfvNV_ovr_0(texCoordSet, pname, value[0]) else
z_GetPathTexGenfvNV_ovr_0_anh0001(texCoordSet, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; var value: single) :=
z_GetPathTexGenfvNV_ovr_0(texCoordSet, pname, value);
private static procedure z_GetPathTexGenfvNV_ovr_2(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
external 'opengl32.dll' name 'glGetPathTexGenfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr) :=
z_GetPathTexGenfvNV_ovr_2(texCoordSet, pname, value);
private static procedure z_MatrixFrustumEXT_ovr_0(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glMatrixFrustumEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixFrustumEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_MatrixFrustumEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
private static procedure z_MatrixLoadIdentityEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixLoadIdentityEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadIdentityEXT(mode: MatrixMode) :=
z_MatrixLoadIdentityEXT_ovr_0(mode);
private static procedure z_MatrixLoadTransposefEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
private static procedure z_MatrixLoadTransposefEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadTransposefEXT_ovr_0(mode, m[0]) else
z_MatrixLoadTransposefEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; var m: single) :=
z_MatrixLoadTransposefEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadTransposefEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadTransposefEXT_ovr_2(mode, m);
private static procedure z_MatrixLoadTransposedEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
private static procedure z_MatrixLoadTransposedEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadTransposedEXT_ovr_0(mode, m[0]) else
z_MatrixLoadTransposedEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; var m: real) :=
z_MatrixLoadTransposedEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadTransposedEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadTransposedEXT_ovr_2(mode, m);
private static procedure z_MatrixLoadfEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
private static procedure z_MatrixLoadfEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoadfEXT_ovr_0(mode, m[0]) else
z_MatrixLoadfEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; var m: single) :=
z_MatrixLoadfEXT_ovr_0(mode, m);
private static procedure z_MatrixLoadfEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoadfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoadfEXT_ovr_2(mode, m);
private static procedure z_MatrixLoaddEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
private static procedure z_MatrixLoaddEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixLoaddEXT_ovr_0(mode, m[0]) else
z_MatrixLoaddEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; var m: real) :=
z_MatrixLoaddEXT_ovr_0(mode, m);
private static procedure z_MatrixLoaddEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixLoaddEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixLoaddEXT_ovr_2(mode, m);
private static procedure z_MatrixMultTransposefEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
private static procedure z_MatrixMultTransposefEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultTransposefEXT_ovr_0(mode, m[0]) else
z_MatrixMultTransposefEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; var m: single) :=
z_MatrixMultTransposefEXT_ovr_0(mode, m);
private static procedure z_MatrixMultTransposefEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultTransposefEXT_ovr_2(mode, m);
private static procedure z_MatrixMultTransposedEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
private static procedure z_MatrixMultTransposedEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultTransposedEXT_ovr_0(mode, m[0]) else
z_MatrixMultTransposedEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; var m: real) :=
z_MatrixMultTransposedEXT_ovr_0(mode, m);
private static procedure z_MatrixMultTransposedEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultTransposedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultTransposedEXT_ovr_2(mode, m);
private static procedure z_MatrixMultfEXT_ovr_0(mode: MatrixMode; var m: single);
external 'opengl32.dll' name 'glMatrixMultfEXT';
private static procedure z_MatrixMultfEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: array of single) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultfEXT_ovr_0(mode, m[0]) else
z_MatrixMultfEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; var m: single) :=
z_MatrixMultfEXT_ovr_0(mode, m);
private static procedure z_MatrixMultfEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultfEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultfEXT_ovr_2(mode, m);
private static procedure z_MatrixMultdEXT_ovr_0(mode: MatrixMode; var m: real);
external 'opengl32.dll' name 'glMatrixMultdEXT';
private static procedure z_MatrixMultdEXT_ovr_0_anh001(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: array of real) :=
if (m<>nil) and (m.Length<>0) then
z_MatrixMultdEXT_ovr_0(mode, m[0]) else
z_MatrixMultdEXT_ovr_0_anh001(mode, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; var m: real) :=
z_MatrixMultdEXT_ovr_0(mode, m);
private static procedure z_MatrixMultdEXT_ovr_2(mode: MatrixMode; m: IntPtr);
external 'opengl32.dll' name 'glMatrixMultdEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: IntPtr) :=
z_MatrixMultdEXT_ovr_2(mode, m);
private static procedure z_MatrixOrthoEXT_ovr_0(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glMatrixOrthoEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixOrthoEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) :=
z_MatrixOrthoEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
private static procedure z_MatrixPopEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixPopEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPopEXT(mode: MatrixMode) :=
z_MatrixPopEXT_ovr_0(mode);
private static procedure z_MatrixPushEXT_ovr_0(mode: MatrixMode);
external 'opengl32.dll' name 'glMatrixPushEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPushEXT(mode: MatrixMode) :=
z_MatrixPushEXT_ovr_0(mode);
private static procedure z_MatrixRotatefEXT_ovr_0(mode: MatrixMode; angle: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixRotatefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatefEXT(mode: MatrixMode; angle: single; x: single; y: single; z: single) :=
z_MatrixRotatefEXT_ovr_0(mode, angle, x, y, z);
private static procedure z_MatrixRotatedEXT_ovr_0(mode: MatrixMode; angle: real; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixRotatedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatedEXT(mode: MatrixMode; angle: real; x: real; y: real; z: real) :=
z_MatrixRotatedEXT_ovr_0(mode, angle, x, y, z);
private static procedure z_MatrixScalefEXT_ovr_0(mode: MatrixMode; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixScalefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScalefEXT(mode: MatrixMode; x: single; y: single; z: single) :=
z_MatrixScalefEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixScaledEXT_ovr_0(mode: MatrixMode; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixScaledEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScaledEXT(mode: MatrixMode; x: real; y: real; z: real) :=
z_MatrixScaledEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixTranslatefEXT_ovr_0(mode: MatrixMode; x: single; y: single; z: single);
external 'opengl32.dll' name 'glMatrixTranslatefEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatefEXT(mode: MatrixMode; x: single; y: single; z: single) :=
z_MatrixTranslatefEXT_ovr_0(mode, x, y, z);
private static procedure z_MatrixTranslatedEXT_ovr_0(mode: MatrixMode; x: real; y: real; z: real);
external 'opengl32.dll' name 'glMatrixTranslatedEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatedEXT(mode: MatrixMode; x: real; y: real; z: real) :=
z_MatrixTranslatedEXT_ovr_0(mode, x, y, z);
end;
[PCUNotRestore]
glPixelDataRangeNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PixelDataRangeNV_ovr_0(target: PixelDataRangeTargetNV; length: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glPixelDataRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelDataRangeNV(target: PixelDataRangeTargetNV; length: Int32; pointer: IntPtr) :=
z_PixelDataRangeNV_ovr_0(target, length, pointer);
private static procedure z_FlushPixelDataRangeNV_ovr_0(target: PixelDataRangeTargetNV);
external 'opengl32.dll' name 'glFlushPixelDataRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushPixelDataRangeNV(target: PixelDataRangeTargetNV) :=
z_FlushPixelDataRangeNV_ovr_0(target);
end;
[PCUNotRestore]
glPointSpriteNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PointParameteriNV_ovr_0(pname: PointParameterNameARB; param: Int32);
external 'opengl32.dll' name 'glPointParameteriNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriNV(pname: PointParameterNameARB; param: Int32) :=
z_PointParameteriNV_ovr_0(pname, param);
private static procedure z_PointParameterivNV_ovr_0(pname: PointParameterNameARB; var ¶ms: Int32);
external 'opengl32.dll' name 'glPointParameterivNV';
private static procedure z_PointParameterivNV_ovr_0_anh001(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterivNV_ovr_0(pname, ¶ms[0]) else
z_PointParameterivNV_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; var ¶ms: Int32) :=
z_PointParameterivNV_ovr_0(pname, ¶ms);
private static procedure z_PointParameterivNV_ovr_2(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterivNV_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glPresentVideoNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PresentFrameKeyedNV_ovr_0(video_slot: UInt32; minPresentTime: UInt64; beginPresentTimeId: UInt32; presentDurationId: UInt32; &type: DummyEnum; target0: DummyEnum; fill0: UInt32; key0: UInt32; target1: DummyEnum; fill1: UInt32; key1: UInt32);
external 'opengl32.dll' name 'glPresentFrameKeyedNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PresentFrameKeyedNV(video_slot: UInt32; minPresentTime: UInt64; beginPresentTimeId: UInt32; presentDurationId: UInt32; &type: DummyEnum; target0: DummyEnum; fill0: UInt32; key0: UInt32; target1: DummyEnum; fill1: UInt32; key1: UInt32) :=
z_PresentFrameKeyedNV_ovr_0(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, &type, target0, fill0, key0, target1, fill1, key1);
private static procedure z_PresentFrameDualFillNV_ovr_0(video_slot: UInt32; minPresentTime: UInt64; beginPresentTimeId: UInt32; presentDurationId: UInt32; &type: DummyEnum; target0: DummyEnum; fill0: UInt32; target1: DummyEnum; fill1: UInt32; target2: DummyEnum; fill2: UInt32; target3: DummyEnum; fill3: UInt32);
external 'opengl32.dll' name 'glPresentFrameDualFillNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PresentFrameDualFillNV(video_slot: UInt32; minPresentTime: UInt64; beginPresentTimeId: UInt32; presentDurationId: UInt32; &type: DummyEnum; target0: DummyEnum; fill0: UInt32; target1: DummyEnum; fill1: UInt32; target2: DummyEnum; fill2: UInt32; target3: DummyEnum; fill3: UInt32) :=
z_PresentFrameDualFillNV_ovr_0(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, &type, target0, fill0, target1, fill1, target2, fill2, target3, fill3);
private static procedure z_GetVideoivNV_ovr_0(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVideoivNV';
private static procedure z_GetVideoivNV_ovr_0_anh0001(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoivNV_ovr_0(video_slot, pname, ¶ms[0]) else
z_GetVideoivNV_ovr_0_anh0001(video_slot, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_GetVideoivNV_ovr_0(video_slot, pname, ¶ms);
private static procedure z_GetVideoivNV_ovr_2(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoivNV_ovr_2(video_slot, pname, ¶ms);
private static procedure z_GetVideouivNV_ovr_0(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetVideouivNV';
private static procedure z_GetVideouivNV_ovr_0_anh0001(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideouivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideouivNV_ovr_0(video_slot, pname, ¶ms[0]) else
z_GetVideouivNV_ovr_0_anh0001(video_slot, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt32) :=
z_GetVideouivNV_ovr_0(video_slot, pname, ¶ms);
private static procedure z_GetVideouivNV_ovr_2(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideouivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideouivNV_ovr_2(video_slot, pname, ¶ms);
private static procedure z_GetVideoi64vNV_ovr_0(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetVideoi64vNV';
private static procedure z_GetVideoi64vNV_ovr_0_anh0001(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoi64vNV_ovr_0(video_slot, pname, ¶ms[0]) else
z_GetVideoi64vNV_ovr_0_anh0001(video_slot, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int64) :=
z_GetVideoi64vNV_ovr_0(video_slot, pname, ¶ms);
private static procedure z_GetVideoi64vNV_ovr_2(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoi64vNV_ovr_2(video_slot, pname, ¶ms);
private static procedure z_GetVideoui64vNV_ovr_0(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetVideoui64vNV';
private static procedure z_GetVideoui64vNV_ovr_0_anh0001(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoui64vNV_ovr_0(video_slot, pname, ¶ms[0]) else
z_GetVideoui64vNV_ovr_0_anh0001(video_slot, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt64) :=
z_GetVideoui64vNV_ovr_0(video_slot, pname, ¶ms);
private static procedure z_GetVideoui64vNV_ovr_2(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoui64vNV_ovr_2(video_slot, pname, ¶ms);
end;
[PCUNotRestore]
glPrimitiveRestartNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PrimitiveRestartNV_ovr_0;
external 'opengl32.dll' name 'glPrimitiveRestartNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartNV :=
z_PrimitiveRestartNV_ovr_0;
private static procedure z_PrimitiveRestartIndexNV_ovr_0(index: UInt32);
external 'opengl32.dll' name 'glPrimitiveRestartIndexNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartIndexNV(index: UInt32) :=
z_PrimitiveRestartIndexNV_ovr_0(index);
end;
[PCUNotRestore]
glQueryResourceNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_QueryResourceNV_ovr_0(queryType: DummyEnum; tagId: Int32; count: UInt32; var buffer: Int32): Int32;
external 'opengl32.dll' name 'glQueryResourceNV';
private static function z_QueryResourceNV_ovr_0_anh00001(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: IntPtr): Int32;
external 'opengl32.dll' name 'glQueryResourceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: array of Int32): Int32 :=
if (buffer<>nil) and (buffer.Length<>0) then
z_QueryResourceNV_ovr_0(queryType, tagId, count, buffer[0]) else
z_QueryResourceNV_ovr_0_anh00001(queryType, tagId, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; var buffer: Int32): Int32 :=
z_QueryResourceNV_ovr_0(queryType, tagId, count, buffer);
private static function z_QueryResourceNV_ovr_2(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: IntPtr): Int32;
external 'opengl32.dll' name 'glQueryResourceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: IntPtr): Int32 :=
z_QueryResourceNV_ovr_2(queryType, tagId, count, buffer);
end;
[PCUNotRestore]
glQueryResourceTagNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GenQueryResourceTagNV_ovr_0(n: Int32; var tagIds: Int32);
external 'opengl32.dll' name 'glGenQueryResourceTagNV';
private static procedure z_GenQueryResourceTagNV_ovr_0_anh001(n: Int32; tagIds: IntPtr);
external 'opengl32.dll' name 'glGenQueryResourceTagNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; tagIds: array of Int32) :=
if (tagIds<>nil) and (tagIds.Length<>0) then
z_GenQueryResourceTagNV_ovr_0(n, tagIds[0]) else
z_GenQueryResourceTagNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; var tagIds: Int32) :=
z_GenQueryResourceTagNV_ovr_0(n, tagIds);
private static procedure z_GenQueryResourceTagNV_ovr_2(n: Int32; tagIds: IntPtr);
external 'opengl32.dll' name 'glGenQueryResourceTagNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; tagIds: IntPtr) :=
z_GenQueryResourceTagNV_ovr_2(n, tagIds);
private static procedure z_DeleteQueryResourceTagNV_ovr_0(n: Int32; var tagIds: Int32);
external 'opengl32.dll' name 'glDeleteQueryResourceTagNV';
private static procedure z_DeleteQueryResourceTagNV_ovr_0_anh001(n: Int32; tagIds: IntPtr);
external 'opengl32.dll' name 'glDeleteQueryResourceTagNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; tagIds: array of Int32) :=
if (tagIds<>nil) and (tagIds.Length<>0) then
z_DeleteQueryResourceTagNV_ovr_0(n, tagIds[0]) else
z_DeleteQueryResourceTagNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; var tagIds: Int32) :=
z_DeleteQueryResourceTagNV_ovr_0(n, tagIds);
private static procedure z_DeleteQueryResourceTagNV_ovr_2(n: Int32; tagIds: IntPtr);
external 'opengl32.dll' name 'glDeleteQueryResourceTagNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; tagIds: IntPtr) :=
z_DeleteQueryResourceTagNV_ovr_2(n, tagIds);
private static procedure z_QueryResourceTagNV_ovr_0(tagId: Int32; tagString: IntPtr);
external 'opengl32.dll' name 'glQueryResourceTagNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryResourceTagNV(tagId: Int32; tagString: string);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(tagString);
z_QueryResourceTagNV_ovr_0(tagId, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryResourceTagNV(tagId: Int32; tagString: IntPtr) :=
z_QueryResourceTagNV_ovr_0(tagId, tagString);
end;
[PCUNotRestore]
glRegisterCombinersNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CombinerParameterfvNV_ovr_0(pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glCombinerParameterfvNV';
private static procedure z_CombinerParameterfvNV_ovr_0_anh001(pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_CombinerParameterfvNV_ovr_0(pname, ¶ms[0]) else
z_CombinerParameterfvNV_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; var ¶ms: single) :=
z_CombinerParameterfvNV_ovr_0(pname, ¶ms);
private static procedure z_CombinerParameterfvNV_ovr_2(pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_CombinerParameterfvNV_ovr_2(pname, ¶ms);
private static procedure z_CombinerParameterfNV_ovr_0(pname: CombinerParameterNV; param: single);
external 'opengl32.dll' name 'glCombinerParameterfNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfNV(pname: CombinerParameterNV; param: single) :=
z_CombinerParameterfNV_ovr_0(pname, param);
private static procedure z_CombinerParameterivNV_ovr_0(pname: CombinerParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glCombinerParameterivNV';
private static procedure z_CombinerParameterivNV_ovr_0_anh001(pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_CombinerParameterivNV_ovr_0(pname, ¶ms[0]) else
z_CombinerParameterivNV_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; var ¶ms: Int32) :=
z_CombinerParameterivNV_ovr_0(pname, ¶ms);
private static procedure z_CombinerParameterivNV_ovr_2(pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_CombinerParameterivNV_ovr_2(pname, ¶ms);
private static procedure z_CombinerParameteriNV_ovr_0(pname: CombinerParameterNV; param: Int32);
external 'opengl32.dll' name 'glCombinerParameteriNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameteriNV(pname: CombinerParameterNV; param: Int32) :=
z_CombinerParameteriNV_ovr_0(pname, param);
private static procedure z_CombinerInputNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV);
external 'opengl32.dll' name 'glCombinerInputNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerInputNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV) :=
z_CombinerInputNV_ovr_0(stage, portion, variable, input, mapping, componentUsage);
private static procedure z_CombinerOutputNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; abOutput: CombinerRegisterNV; cdOutput: CombinerRegisterNV; sumOutput: CombinerRegisterNV; scale: CombinerScaleNV; bias: CombinerBiasNV; abDotProduct: boolean; cdDotProduct: boolean; muxSum: boolean);
external 'opengl32.dll' name 'glCombinerOutputNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerOutputNV(stage: CombinerStageNV; portion: CombinerPortionNV; abOutput: CombinerRegisterNV; cdOutput: CombinerRegisterNV; sumOutput: CombinerRegisterNV; scale: CombinerScaleNV; bias: CombinerBiasNV; abDotProduct: boolean; cdDotProduct: boolean; muxSum: boolean) :=
z_CombinerOutputNV_ovr_0(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
private static procedure z_FinalCombinerInputNV_ovr_0(variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV);
external 'opengl32.dll' name 'glFinalCombinerInputNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinalCombinerInputNV(variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV) :=
z_FinalCombinerInputNV_ovr_0(variable, input, mapping, componentUsage);
private static procedure z_GetCombinerInputParameterfvNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetCombinerInputParameterfvNV';
private static procedure z_GetCombinerInputParameterfvNV_ovr_0_anh000001(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerInputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetCombinerInputParameterfvNV_ovr_0(stage, portion, variable, pname, ¶ms[0]) else
z_GetCombinerInputParameterfvNV_ovr_0_anh000001(stage, portion, variable, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single) :=
z_GetCombinerInputParameterfvNV_ovr_0(stage, portion, variable, pname, ¶ms);
private static procedure z_GetCombinerInputParameterfvNV_ovr_2(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerInputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetCombinerInputParameterfvNV_ovr_2(stage, portion, variable, pname, ¶ms);
private static procedure z_GetCombinerInputParameterivNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetCombinerInputParameterivNV';
private static procedure z_GetCombinerInputParameterivNV_ovr_0_anh000001(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerInputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetCombinerInputParameterivNV_ovr_0(stage, portion, variable, pname, ¶ms[0]) else
z_GetCombinerInputParameterivNV_ovr_0_anh000001(stage, portion, variable, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32) :=
z_GetCombinerInputParameterivNV_ovr_0(stage, portion, variable, pname, ¶ms);
private static procedure z_GetCombinerInputParameterivNV_ovr_2(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerInputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetCombinerInputParameterivNV_ovr_2(stage, portion, variable, pname, ¶ms);
private static procedure z_GetCombinerOutputParameterfvNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetCombinerOutputParameterfvNV';
private static procedure z_GetCombinerOutputParameterfvNV_ovr_0_anh00001(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerOutputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetCombinerOutputParameterfvNV_ovr_0(stage, portion, pname, ¶ms[0]) else
z_GetCombinerOutputParameterfvNV_ovr_0_anh00001(stage, portion, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: single) :=
z_GetCombinerOutputParameterfvNV_ovr_0(stage, portion, pname, ¶ms);
private static procedure z_GetCombinerOutputParameterfvNV_ovr_2(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerOutputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetCombinerOutputParameterfvNV_ovr_2(stage, portion, pname, ¶ms);
private static procedure z_GetCombinerOutputParameterivNV_ovr_0(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetCombinerOutputParameterivNV';
private static procedure z_GetCombinerOutputParameterivNV_ovr_0_anh00001(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerOutputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetCombinerOutputParameterivNV_ovr_0(stage, portion, pname, ¶ms[0]) else
z_GetCombinerOutputParameterivNV_ovr_0_anh00001(stage, portion, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: Int32) :=
z_GetCombinerOutputParameterivNV_ovr_0(stage, portion, pname, ¶ms);
private static procedure z_GetCombinerOutputParameterivNV_ovr_2(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerOutputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetCombinerOutputParameterivNV_ovr_2(stage, portion, pname, ¶ms);
private static procedure z_GetFinalCombinerInputParameterfvNV_ovr_0(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterfvNV';
private static procedure z_GetFinalCombinerInputParameterfvNV_ovr_0_anh0001(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFinalCombinerInputParameterfvNV_ovr_0(variable, pname, ¶ms[0]) else
z_GetFinalCombinerInputParameterfvNV_ovr_0_anh0001(variable, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single) :=
z_GetFinalCombinerInputParameterfvNV_ovr_0(variable, pname, ¶ms);
private static procedure z_GetFinalCombinerInputParameterfvNV_ovr_2(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetFinalCombinerInputParameterfvNV_ovr_2(variable, pname, ¶ms);
private static procedure z_GetFinalCombinerInputParameterivNV_ovr_0(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterivNV';
private static procedure z_GetFinalCombinerInputParameterivNV_ovr_0_anh0001(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFinalCombinerInputParameterivNV_ovr_0(variable, pname, ¶ms[0]) else
z_GetFinalCombinerInputParameterivNV_ovr_0_anh0001(variable, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32) :=
z_GetFinalCombinerInputParameterivNV_ovr_0(variable, pname, ¶ms);
private static procedure z_GetFinalCombinerInputParameterivNV_ovr_2(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFinalCombinerInputParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetFinalCombinerInputParameterivNV_ovr_2(variable, pname, ¶ms);
end;
[PCUNotRestore]
glRegisterCombiners2NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_CombinerStageParameterfvNV_ovr_0(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glCombinerStageParameterfvNV';
private static procedure z_CombinerStageParameterfvNV_ovr_0_anh0001(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerStageParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_CombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms[0]) else
z_CombinerStageParameterfvNV_ovr_0_anh0001(stage, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single) :=
z_CombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms);
private static procedure z_CombinerStageParameterfvNV_ovr_2(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glCombinerStageParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_CombinerStageParameterfvNV_ovr_2(stage, pname, ¶ms);
private static procedure z_GetCombinerStageParameterfvNV_ovr_0(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetCombinerStageParameterfvNV';
private static procedure z_GetCombinerStageParameterfvNV_ovr_0_anh0001(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerStageParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetCombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms[0]) else
z_GetCombinerStageParameterfvNV_ovr_0_anh0001(stage, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single) :=
z_GetCombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms);
private static procedure z_GetCombinerStageParameterfvNV_ovr_2(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetCombinerStageParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr) :=
z_GetCombinerStageParameterfvNV_ovr_2(stage, pname, ¶ms);
end;
[PCUNotRestore]
glSampleLocationsNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferSampleLocationsfvNV_ovr_0(target: FramebufferTarget; start: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvNV';
private static procedure z_FramebufferSampleLocationsfvNV_ovr_0_anh00001(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_FramebufferSampleLocationsfvNV_ovr_0(target, start, count, v[0]) else
z_FramebufferSampleLocationsfvNV_ovr_0_anh00001(target, start, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; var v: single) :=
z_FramebufferSampleLocationsfvNV_ovr_0(target, start, count, v);
private static procedure z_FramebufferSampleLocationsfvNV_ovr_2(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr) :=
z_FramebufferSampleLocationsfvNV_ovr_2(target, start, count, v);
private static procedure z_NamedFramebufferSampleLocationsfvNV_ovr_0(framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvNV';
private static procedure z_NamedFramebufferSampleLocationsfvNV_ovr_0_anh00001(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_NamedFramebufferSampleLocationsfvNV_ovr_0(framebuffer, start, count, v[0]) else
z_NamedFramebufferSampleLocationsfvNV_ovr_0_anh00001(framebuffer, start, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; var v: single) :=
z_NamedFramebufferSampleLocationsfvNV_ovr_0(framebuffer, start, count, v);
private static procedure z_NamedFramebufferSampleLocationsfvNV_ovr_2(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glNamedFramebufferSampleLocationsfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr) :=
z_NamedFramebufferSampleLocationsfvNV_ovr_2(framebuffer, start, count, v);
private static procedure z_ResolveDepthValuesNV_ovr_0;
external 'opengl32.dll' name 'glResolveDepthValuesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResolveDepthValuesNV :=
z_ResolveDepthValuesNV_ovr_0;
end;
[PCUNotRestore]
glScissorExclusiveNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ScissorExclusiveNV_ovr_0(x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glScissorExclusiveNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveNV(x: Int32; y: Int32; width: Int32; height: Int32) :=
z_ScissorExclusiveNV_ovr_0(x, y, width, height);
private static procedure z_ScissorExclusiveArrayvNV_ovr_0(first: UInt32; count: Int32; var v: Int32);
external 'opengl32.dll' name 'glScissorExclusiveArrayvNV';
private static procedure z_ScissorExclusiveArrayvNV_ovr_0_anh0001(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glScissorExclusiveArrayvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_ScissorExclusiveArrayvNV_ovr_0(first, count, v[0]) else
z_ScissorExclusiveArrayvNV_ovr_0_anh0001(first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; var v: Int32) :=
z_ScissorExclusiveArrayvNV_ovr_0(first, count, v);
private static procedure z_ScissorExclusiveArrayvNV_ovr_2(first: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glScissorExclusiveArrayvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; v: IntPtr) :=
z_ScissorExclusiveArrayvNV_ovr_2(first, count, v);
end;
[PCUNotRestore]
glShaderBufferLoadNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MakeBufferResidentNV_ovr_0(target: DummyEnum; access: DummyEnum);
external 'opengl32.dll' name 'glMakeBufferResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeBufferResidentNV(target: DummyEnum; access: DummyEnum) :=
z_MakeBufferResidentNV_ovr_0(target, access);
private static procedure z_MakeBufferNonResidentNV_ovr_0(target: DummyEnum);
external 'opengl32.dll' name 'glMakeBufferNonResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeBufferNonResidentNV(target: DummyEnum) :=
z_MakeBufferNonResidentNV_ovr_0(target);
private static function z_IsBufferResidentNV_ovr_0(target: DummyEnum): boolean;
external 'opengl32.dll' name 'glIsBufferResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBufferResidentNV(target: DummyEnum): boolean :=
z_IsBufferResidentNV_ovr_0(target);
private static procedure z_MakeNamedBufferResidentNV_ovr_0(buffer: UInt32; access: DummyEnum);
external 'opengl32.dll' name 'glMakeNamedBufferResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeNamedBufferResidentNV(buffer: UInt32; access: DummyEnum) :=
z_MakeNamedBufferResidentNV_ovr_0(buffer, access);
private static procedure z_MakeNamedBufferNonResidentNV_ovr_0(buffer: UInt32);
external 'opengl32.dll' name 'glMakeNamedBufferNonResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeNamedBufferNonResidentNV(buffer: UInt32) :=
z_MakeNamedBufferNonResidentNV_ovr_0(buffer);
private static function z_IsNamedBufferResidentNV_ovr_0(buffer: UInt32): boolean;
external 'opengl32.dll' name 'glIsNamedBufferResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNamedBufferResidentNV(buffer: UInt32): boolean :=
z_IsNamedBufferResidentNV_ovr_0(buffer);
private static procedure z_GetBufferParameterui64vNV_ovr_0(target: BufferTargetARB; pname: DummyEnum; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetBufferParameterui64vNV';
private static procedure z_GetBufferParameterui64vNV_ovr_0_anh0001(target: BufferTargetARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferParameterui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetBufferParameterui64vNV_ovr_0(target, pname, ¶ms[0]) else
z_GetBufferParameterui64vNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; var ¶ms: UInt64) :=
z_GetBufferParameterui64vNV_ovr_0(target, pname, ¶ms);
private static procedure z_GetBufferParameterui64vNV_ovr_2(target: BufferTargetARB; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetBufferParameterui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetBufferParameterui64vNV_ovr_2(target, pname, ¶ms);
private static procedure z_GetNamedBufferParameterui64vNV_ovr_0(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetNamedBufferParameterui64vNV';
private static procedure z_GetNamedBufferParameterui64vNV_ovr_0_anh0001(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameterui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetNamedBufferParameterui64vNV_ovr_0(buffer, pname, ¶ms[0]) else
z_GetNamedBufferParameterui64vNV_ovr_0_anh0001(buffer, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: UInt64) :=
z_GetNamedBufferParameterui64vNV_ovr_0(buffer, pname, ¶ms);
private static procedure z_GetNamedBufferParameterui64vNV_ovr_2(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetNamedBufferParameterui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr) :=
z_GetNamedBufferParameterui64vNV_ovr_2(buffer, pname, ¶ms);
private static procedure z_GetIntegerui64vNV_ovr_0(value: DummyEnum; var result: UInt64);
external 'opengl32.dll' name 'glGetIntegerui64vNV';
private static procedure z_GetIntegerui64vNV_ovr_0_anh001(value: DummyEnum; result: IntPtr);
external 'opengl32.dll' name 'glGetIntegerui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; result: array of UInt64) :=
if (result<>nil) and (result.Length<>0) then
z_GetIntegerui64vNV_ovr_0(value, result[0]) else
z_GetIntegerui64vNV_ovr_0_anh001(value, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; var result: UInt64) :=
z_GetIntegerui64vNV_ovr_0(value, result);
private static procedure z_GetIntegerui64vNV_ovr_2(value: DummyEnum; result: IntPtr);
external 'opengl32.dll' name 'glGetIntegerui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; result: IntPtr) :=
z_GetIntegerui64vNV_ovr_2(value, result);
private static procedure z_Uniformui64NV_ovr_0(location: Int32; value: UInt64);
external 'opengl32.dll' name 'glUniformui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64NV(location: Int32; value: UInt64) :=
z_Uniformui64NV_ovr_0(location, value);
private static procedure z_Uniformui64vNV_ovr_0(location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glUniformui64vNV';
private static procedure z_Uniformui64vNV_ovr_0_anh0001(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_Uniformui64vNV_ovr_0(location, count, value[0]) else
z_Uniformui64vNV_ovr_0_anh0001(location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; var value: UInt64) :=
z_Uniformui64vNV_ovr_0(location, count, value);
private static procedure z_Uniformui64vNV_ovr_2(location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; value: IntPtr) :=
z_Uniformui64vNV_ovr_2(location, count, value);
private static procedure z_GetUniformui64vNV_ovr_0(&program: UInt32; location: Int32; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetUniformui64vNV';
private static procedure z_GetUniformui64vNV_ovr_0_anh0001(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms[0]) else
z_GetUniformui64vNV_ovr_0_anh0001(&program, location, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; var ¶ms: UInt64) :=
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms);
private static procedure z_GetUniformui64vNV_ovr_2(&program: UInt32; location: Int32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr) :=
z_GetUniformui64vNV_ovr_2(&program, location, ¶ms);
private static procedure z_ProgramUniformui64NV_ovr_0(&program: UInt32; location: Int32; value: UInt64);
external 'opengl32.dll' name 'glProgramUniformui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64NV(&program: UInt32; location: Int32; value: UInt64) :=
z_ProgramUniformui64NV_ovr_0(&program, location, value);
private static procedure z_ProgramUniformui64vNV_ovr_0(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
external 'opengl32.dll' name 'glProgramUniformui64vNV';
private static procedure z_ProgramUniformui64vNV_ovr_0_anh00001(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64) :=
if (value<>nil) and (value.Length<>0) then
z_ProgramUniformui64vNV_ovr_0(&program, location, count, value[0]) else
z_ProgramUniformui64vNV_ovr_0_anh00001(&program, location, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64) :=
z_ProgramUniformui64vNV_ovr_0(&program, location, count, value);
private static procedure z_ProgramUniformui64vNV_ovr_2(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
external 'opengl32.dll' name 'glProgramUniformui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr) :=
z_ProgramUniformui64vNV_ovr_2(&program, location, count, value);
end;
[PCUNotRestore]
glShadingRateImageNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindShadingRateImageNV_ovr_0(texture: UInt32);
external 'opengl32.dll' name 'glBindShadingRateImageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindShadingRateImageNV(texture: UInt32) :=
z_BindShadingRateImageNV_ovr_0(texture);
private static procedure z_GetShadingRateImagePaletteNV_ovr_0(viewport: UInt32; entry: UInt32; var rate: DummyEnum);
external 'opengl32.dll' name 'glGetShadingRateImagePaletteNV';
private static procedure z_GetShadingRateImagePaletteNV_ovr_0_anh0001(viewport: UInt32; entry: UInt32; rate: IntPtr);
external 'opengl32.dll' name 'glGetShadingRateImagePaletteNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; rate: array of DummyEnum) :=
if (rate<>nil) and (rate.Length<>0) then
z_GetShadingRateImagePaletteNV_ovr_0(viewport, entry, rate[0]) else
z_GetShadingRateImagePaletteNV_ovr_0_anh0001(viewport, entry, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; var rate: DummyEnum) :=
z_GetShadingRateImagePaletteNV_ovr_0(viewport, entry, rate);
private static procedure z_GetShadingRateImagePaletteNV_ovr_2(viewport: UInt32; entry: UInt32; rate: IntPtr);
external 'opengl32.dll' name 'glGetShadingRateImagePaletteNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; rate: IntPtr) :=
z_GetShadingRateImagePaletteNV_ovr_2(viewport, entry, rate);
private static procedure z_GetShadingRateSampleLocationivNV_ovr_0(rate: DummyEnum; samples: UInt32; index: UInt32; var location: Int32);
external 'opengl32.dll' name 'glGetShadingRateSampleLocationivNV';
private static procedure z_GetShadingRateSampleLocationivNV_ovr_0_anh00001(rate: DummyEnum; samples: UInt32; index: UInt32; location: IntPtr);
external 'opengl32.dll' name 'glGetShadingRateSampleLocationivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; location: array of Int32) :=
if (location<>nil) and (location.Length<>0) then
z_GetShadingRateSampleLocationivNV_ovr_0(rate, samples, index, location[0]) else
z_GetShadingRateSampleLocationivNV_ovr_0_anh00001(rate, samples, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; var location: Int32) :=
z_GetShadingRateSampleLocationivNV_ovr_0(rate, samples, index, location);
private static procedure z_GetShadingRateSampleLocationivNV_ovr_2(rate: DummyEnum; samples: UInt32; index: UInt32; location: IntPtr);
external 'opengl32.dll' name 'glGetShadingRateSampleLocationivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; location: IntPtr) :=
z_GetShadingRateSampleLocationivNV_ovr_2(rate, samples, index, location);
private static procedure z_ShadingRateImageBarrierNV_ovr_0(synchronize: boolean);
external 'opengl32.dll' name 'glShadingRateImageBarrierNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImageBarrierNV(synchronize: boolean) :=
z_ShadingRateImageBarrierNV_ovr_0(synchronize);
private static procedure z_ShadingRateImagePaletteNV_ovr_0(viewport: UInt32; first: UInt32; count: Int32; var rates: DummyEnum);
external 'opengl32.dll' name 'glShadingRateImagePaletteNV';
private static procedure z_ShadingRateImagePaletteNV_ovr_0_anh00001(viewport: UInt32; first: UInt32; count: Int32; rates: IntPtr);
external 'opengl32.dll' name 'glShadingRateImagePaletteNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; rates: array of DummyEnum) :=
if (rates<>nil) and (rates.Length<>0) then
z_ShadingRateImagePaletteNV_ovr_0(viewport, first, count, rates[0]) else
z_ShadingRateImagePaletteNV_ovr_0_anh00001(viewport, first, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; var rates: DummyEnum) :=
z_ShadingRateImagePaletteNV_ovr_0(viewport, first, count, rates);
private static procedure z_ShadingRateImagePaletteNV_ovr_2(viewport: UInt32; first: UInt32; count: Int32; rates: IntPtr);
external 'opengl32.dll' name 'glShadingRateImagePaletteNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; rates: IntPtr) :=
z_ShadingRateImagePaletteNV_ovr_2(viewport, first, count, rates);
private static procedure z_ShadingRateSampleOrderNV_ovr_0(order: DummyEnum);
external 'opengl32.dll' name 'glShadingRateSampleOrderNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderNV(order: DummyEnum) :=
z_ShadingRateSampleOrderNV_ovr_0(order);
private static procedure z_ShadingRateSampleOrderCustomNV_ovr_0(rate: DummyEnum; samples: UInt32; var locations: Int32);
external 'opengl32.dll' name 'glShadingRateSampleOrderCustomNV';
private static procedure z_ShadingRateSampleOrderCustomNV_ovr_0_anh0001(rate: DummyEnum; samples: UInt32; locations: IntPtr);
external 'opengl32.dll' name 'glShadingRateSampleOrderCustomNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; locations: array of Int32) :=
if (locations<>nil) and (locations.Length<>0) then
z_ShadingRateSampleOrderCustomNV_ovr_0(rate, samples, locations[0]) else
z_ShadingRateSampleOrderCustomNV_ovr_0_anh0001(rate, samples, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; var locations: Int32) :=
z_ShadingRateSampleOrderCustomNV_ovr_0(rate, samples, locations);
private static procedure z_ShadingRateSampleOrderCustomNV_ovr_2(rate: DummyEnum; samples: UInt32; locations: IntPtr);
external 'opengl32.dll' name 'glShadingRateSampleOrderCustomNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; locations: IntPtr) :=
z_ShadingRateSampleOrderCustomNV_ovr_2(rate, samples, locations);
end;
[PCUNotRestore]
glTextureBarrierNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureBarrierNV_ovr_0;
external 'opengl32.dll' name 'glTextureBarrierNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBarrierNV :=
z_TextureBarrierNV_ovr_0;
end;
[PCUNotRestore]
glTextureMultisampleNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexImage2DMultisampleCoverageNV_ovr_0(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTexImage2DMultisampleCoverageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage2DMultisampleCoverageNV(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean) :=
z_TexImage2DMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
private static procedure z_TexImage3DMultisampleCoverageNV_ovr_0(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTexImage3DMultisampleCoverageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3DMultisampleCoverageNV(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean) :=
z_TexImage3DMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
private static procedure z_TextureImage2DMultisampleNV_ovr_0(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTextureImage2DMultisampleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage2DMultisampleNV(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean) :=
z_TextureImage2DMultisampleNV_ovr_0(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
private static procedure z_TextureImage3DMultisampleNV_ovr_0(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTextureImage3DMultisampleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage3DMultisampleNV(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean) :=
z_TextureImage3DMultisampleNV_ovr_0(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
private static procedure z_TextureImage2DMultisampleCoverageNV_ovr_0(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTextureImage2DMultisampleCoverageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage2DMultisampleCoverageNV(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean) :=
z_TextureImage2DMultisampleCoverageNV_ovr_0(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
private static procedure z_TextureImage3DMultisampleCoverageNV_ovr_0(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
external 'opengl32.dll' name 'glTextureImage3DMultisampleCoverageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage3DMultisampleCoverageNV(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean) :=
z_TextureImage3DMultisampleCoverageNV_ovr_0(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
end;
[PCUNotRestore]
glTransformFeedbackNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginTransformFeedbackNV_ovr_0(primitiveMode: PrimitiveType);
external 'opengl32.dll' name 'glBeginTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedbackNV(primitiveMode: PrimitiveType) :=
z_BeginTransformFeedbackNV_ovr_0(primitiveMode);
private static procedure z_EndTransformFeedbackNV_ovr_0;
external 'opengl32.dll' name 'glEndTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedbackNV :=
z_EndTransformFeedbackNV_ovr_0;
private static procedure z_TransformFeedbackAttribsNV_ovr_0(count: Int32; var attribs: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackAttribsNV';
private static procedure z_TransformFeedbackAttribsNV_ovr_0_anh0010(count: Int32; attribs: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; attribs: array of Int32; bufferMode: DummyEnum) :=
if (attribs<>nil) and (attribs.Length<>0) then
z_TransformFeedbackAttribsNV_ovr_0(count, attribs[0], bufferMode) else
z_TransformFeedbackAttribsNV_ovr_0_anh0010(count, IntPtr.Zero, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; var attribs: Int32; bufferMode: DummyEnum) :=
z_TransformFeedbackAttribsNV_ovr_0(count, attribs, bufferMode);
private static procedure z_TransformFeedbackAttribsNV_ovr_2(count: Int32; attribs: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; attribs: IntPtr; bufferMode: DummyEnum) :=
z_TransformFeedbackAttribsNV_ovr_2(count, attribs, bufferMode);
private static procedure z_BindBufferRangeNV_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr);
external 'opengl32.dll' name 'glBindBufferRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeNV(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr) :=
z_BindBufferRangeNV_ovr_0(target, index, buffer, offset, size);
private static procedure z_BindBufferOffsetNV_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr);
external 'opengl32.dll' name 'glBindBufferOffsetNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetNV(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr) :=
z_BindBufferOffsetNV_ovr_0(target, index, buffer, offset);
private static procedure z_BindBufferBaseNV_ovr_0(target: BufferTargetARB; index: UInt32; buffer: UInt32);
external 'opengl32.dll' name 'glBindBufferBaseNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseNV(target: BufferTargetARB; index: UInt32; buffer: UInt32) :=
z_BindBufferBaseNV_ovr_0(target, index, buffer);
private static procedure z_TransformFeedbackVaryingsNV_ovr_0(&program: UInt32; count: Int32; var locations: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsNV';
private static procedure z_TransformFeedbackVaryingsNV_ovr_0_anh00010(&program: UInt32; count: Int32; locations: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; locations: array of Int32; bufferMode: DummyEnum) :=
if (locations<>nil) and (locations.Length<>0) then
z_TransformFeedbackVaryingsNV_ovr_0(&program, count, locations[0], bufferMode) else
z_TransformFeedbackVaryingsNV_ovr_0_anh00010(&program, count, IntPtr.Zero, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; var locations: Int32; bufferMode: DummyEnum) :=
z_TransformFeedbackVaryingsNV_ovr_0(&program, count, locations, bufferMode);
private static procedure z_TransformFeedbackVaryingsNV_ovr_2(&program: UInt32; count: Int32; locations: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackVaryingsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; locations: IntPtr; bufferMode: DummyEnum) :=
z_TransformFeedbackVaryingsNV_ovr_2(&program, count, locations, bufferMode);
private static procedure z_ActiveVaryingNV_ovr_0(&program: UInt32; name: IntPtr);
external 'opengl32.dll' name 'glActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveVaryingNV(&program: UInt32; name: string);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
z_ActiveVaryingNV_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveVaryingNV(&program: UInt32; name: IntPtr) :=
z_ActiveVaryingNV_ovr_0(&program, name);
private static function z_GetVaryingLocationNV_ovr_0(&program: UInt32; name: IntPtr): Int32;
external 'opengl32.dll' name 'glGetVaryingLocationNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetVaryingLocationNV(&program: UInt32; name: string): Int32;
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(name);
Result := z_GetVaryingLocationNV_ovr_0(&program, par_2_str_ptr);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetVaryingLocationNV(&program: UInt32; name: IntPtr): Int32 :=
z_GetVaryingLocationNV_ovr_0(&program, name);
private static procedure z_GetActiveVaryingNV_ovr_0(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00000110(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_0_anh00001110(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: array of DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000010(&program, index, bufSize, length[0], size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000110(&program, index, bufSize, length[0], IntPtr.Zero, IntPtr.Zero, name) else
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00001110(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveVaryingNV_ovr_1_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_1_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_1_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; var &type: DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveVaryingNV_ovr_0_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_0_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_2(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_2_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_2_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_2_anh00001100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length[0], size[0], &type, name) else
z_GetActiveVaryingNV_ovr_2_anh00000100(&program, index, bufSize, length[0], IntPtr.Zero, &type, name) else
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_2_anh00001100(&program, index, bufSize, IntPtr.Zero, IntPtr.Zero, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_3_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_3_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: array of DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveVaryingNV_ovr_4_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveVaryingNV_ovr_0_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_5_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveVaryingNV_ovr_2_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_6(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_6_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_6_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_6_anh00001010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length[0], size, &type[0], name) else
z_GetActiveVaryingNV_ovr_6_anh00000010(&program, index, bufSize, length[0], size, IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_6_anh00001010(&program, index, bufSize, IntPtr.Zero, size, IntPtr.Zero, name);
private static procedure z_GetActiveVaryingNV_ovr_7_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveVaryingNV_ovr_6_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_8(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_8_anh00001000(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_GetActiveVaryingNV_ovr_8(&program, index, bufSize, length[0], size, &type, name) else
z_GetActiveVaryingNV_ovr_8_anh00001000(&program, index, bufSize, IntPtr.Zero, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: array of DummyEnum; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: DummyEnum; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_0_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_2_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of DummyEnum; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_0_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: DummyEnum; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of DummyEnum; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_6_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_8(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_18(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_18_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_18_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_18_anh00000110(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of DummyEnum; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size[0], &type[0], name) else
z_GetActiveVaryingNV_ovr_18_anh00000010(&program, index, bufSize, length, size[0], IntPtr.Zero, name) else
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type[0], name) else
z_GetActiveVaryingNV_ovr_18_anh00000110(&program, index, bufSize, length, IntPtr.Zero, IntPtr.Zero, name);
private static procedure z_GetActiveVaryingNV_ovr_19_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: DummyEnum; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_18_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_20(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_20_anh00000100(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr) :=
if (size<>nil) and (size.Length<>0) then
z_GetActiveVaryingNV_ovr_20(&program, index, bufSize, length, size[0], &type, name) else
z_GetActiveVaryingNV_ovr_20_anh00000100(&program, index, bufSize, length, IntPtr.Zero, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of DummyEnum; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_18_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size, &type, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_20(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_24(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
private static procedure z_GetActiveVaryingNV_ovr_24_anh00000010(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of DummyEnum; name: IntPtr) :=
if (&type<>nil) and (&type.Length<>0) then
z_GetActiveVaryingNV_ovr_24(&program, index, bufSize, length, size, &type[0], name) else
z_GetActiveVaryingNV_ovr_24_anh00000010(&program, index, bufSize, length, size, IntPtr.Zero, name);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_24(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetActiveVaryingNV_ovr_26(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
external 'opengl32.dll' name 'glGetActiveVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr) :=
z_GetActiveVaryingNV_ovr_26(&program, index, bufSize, length, size, &type, name);
private static procedure z_GetTransformFeedbackVaryingNV_ovr_0(&program: UInt32; index: UInt32; var location: Int32);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingNV';
private static procedure z_GetTransformFeedbackVaryingNV_ovr_0_anh0001(&program: UInt32; index: UInt32; location: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; location: array of Int32) :=
if (location<>nil) and (location.Length<>0) then
z_GetTransformFeedbackVaryingNV_ovr_0(&program, index, location[0]) else
z_GetTransformFeedbackVaryingNV_ovr_0_anh0001(&program, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; var location: Int32) :=
z_GetTransformFeedbackVaryingNV_ovr_0(&program, index, location);
private static procedure z_GetTransformFeedbackVaryingNV_ovr_2(&program: UInt32; index: UInt32; location: IntPtr);
external 'opengl32.dll' name 'glGetTransformFeedbackVaryingNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; location: IntPtr) :=
z_GetTransformFeedbackVaryingNV_ovr_2(&program, index, location);
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_0(count: Int32; var attribs: Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_0_anh001000(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_0_anh000010(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_0_anh001010(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum) :=
if (attribs<>nil) and (attribs.Length<>0) then
if (bufstreams<>nil) and (bufstreams.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs[0], nbuffers, bufstreams[0], bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_0_anh000010(count, attribs[0], nbuffers, IntPtr.Zero, bufferMode) else
if (bufstreams<>nil) and (bufstreams.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_0_anh001000(count, IntPtr.Zero, nbuffers, bufstreams[0], bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_0_anh001010(count, IntPtr.Zero, nbuffers, IntPtr.Zero, bufferMode);
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_1_anh001000(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum) :=
if (attribs<>nil) and (attribs.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs[0], nbuffers, bufstreams, bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_0_anh001000(count, IntPtr.Zero, nbuffers, bufstreams, bufferMode);
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_2(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_2_anh001000(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum) :=
if (attribs<>nil) and (attribs.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_2(count, attribs[0], nbuffers, bufstreams, bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_2_anh001000(count, IntPtr.Zero, nbuffers, bufstreams, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum) :=
if (bufstreams<>nil) and (bufstreams.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs, nbuffers, bufstreams[0], bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_0_anh000010(count, attribs, nbuffers, IntPtr.Zero, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum) :=
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs, nbuffers, bufstreams, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum) :=
z_TransformFeedbackStreamAttribsNV_ovr_2(count, attribs, nbuffers, bufstreams, bufferMode);
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_6(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_6_anh000010(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum) :=
if (bufstreams<>nil) and (bufstreams.Length<>0) then
z_TransformFeedbackStreamAttribsNV_ovr_6(count, attribs, nbuffers, bufstreams[0], bufferMode) else
z_TransformFeedbackStreamAttribsNV_ovr_6_anh000010(count, attribs, nbuffers, IntPtr.Zero, bufferMode);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum) :=
z_TransformFeedbackStreamAttribsNV_ovr_6(count, attribs, nbuffers, bufstreams, bufferMode);
private static procedure z_TransformFeedbackStreamAttribsNV_ovr_8(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
external 'opengl32.dll' name 'glTransformFeedbackStreamAttribsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum) :=
z_TransformFeedbackStreamAttribsNV_ovr_8(count, attribs, nbuffers, bufstreams, bufferMode);
end;
[PCUNotRestore]
glTransformFeedback2NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BindTransformFeedbackNV_ovr_0(target: BufferTargetARB; id: UInt32);
external 'opengl32.dll' name 'glBindTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedbackNV(target: BufferTargetARB; id: UInt32) :=
z_BindTransformFeedbackNV_ovr_0(target, id);
private static procedure z_DeleteTransformFeedbacksNV_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glDeleteTransformFeedbacksNV';
private static procedure z_DeleteTransformFeedbacksNV_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteTransformFeedbacksNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_DeleteTransformFeedbacksNV_ovr_0(n, ids[0]) else
z_DeleteTransformFeedbacksNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; var ids: UInt32) :=
z_DeleteTransformFeedbacksNV_ovr_0(n, ids);
private static procedure z_DeleteTransformFeedbacksNV_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glDeleteTransformFeedbacksNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; ids: IntPtr) :=
z_DeleteTransformFeedbacksNV_ovr_2(n, ids);
private static procedure z_GenTransformFeedbacksNV_ovr_0(n: Int32; var ids: UInt32);
external 'opengl32.dll' name 'glGenTransformFeedbacksNV';
private static procedure z_GenTransformFeedbacksNV_ovr_0_anh001(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenTransformFeedbacksNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; ids: array of UInt32) :=
if (ids<>nil) and (ids.Length<>0) then
z_GenTransformFeedbacksNV_ovr_0(n, ids[0]) else
z_GenTransformFeedbacksNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; var ids: UInt32) :=
z_GenTransformFeedbacksNV_ovr_0(n, ids);
private static procedure z_GenTransformFeedbacksNV_ovr_2(n: Int32; ids: IntPtr);
external 'opengl32.dll' name 'glGenTransformFeedbacksNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; ids: IntPtr) :=
z_GenTransformFeedbacksNV_ovr_2(n, ids);
private static function z_IsTransformFeedbackNV_ovr_0(id: UInt32): boolean;
external 'opengl32.dll' name 'glIsTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTransformFeedbackNV(id: UInt32): boolean :=
z_IsTransformFeedbackNV_ovr_0(id);
private static procedure z_PauseTransformFeedbackNV_ovr_0;
external 'opengl32.dll' name 'glPauseTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PauseTransformFeedbackNV :=
z_PauseTransformFeedbackNV_ovr_0;
private static procedure z_ResumeTransformFeedbackNV_ovr_0;
external 'opengl32.dll' name 'glResumeTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResumeTransformFeedbackNV :=
z_ResumeTransformFeedbackNV_ovr_0;
private static procedure z_DrawTransformFeedbackNV_ovr_0(mode: PrimitiveType; id: UInt32);
external 'opengl32.dll' name 'glDrawTransformFeedbackNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackNV(mode: PrimitiveType; id: UInt32) :=
z_DrawTransformFeedbackNV_ovr_0(mode, id);
end;
[PCUNotRestore]
glVdpauInteropNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VDPAUInitNV_ovr_0(vdpDevice: IntPtr; getProcAddress: IntPtr);
external 'opengl32.dll' name 'glVDPAUInitNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUInitNV(vdpDevice: IntPtr; getProcAddress: IntPtr) :=
z_VDPAUInitNV_ovr_0(vdpDevice, getProcAddress);
private static procedure z_VDPAUFiniNV_ovr_0;
external 'opengl32.dll' name 'glVDPAUFiniNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUFiniNV :=
z_VDPAUFiniNV_ovr_0;
private static function z_VDPAURegisterVideoSurfaceNV_ovr_0(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceNV';
private static function z_VDPAURegisterVideoSurfaceNV_ovr_0_anh00001(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32): GLvdpauSurfaceNV :=
if (textureNames<>nil) and (textureNames.Length<>0) then
z_VDPAURegisterVideoSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0]) else
z_VDPAURegisterVideoSurfaceNV_ovr_0_anh00001(vdpSurface, target, numTextureNames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV :=
z_VDPAURegisterVideoSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames);
private static function z_VDPAURegisterVideoSurfaceNV_ovr_2(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV :=
z_VDPAURegisterVideoSurfaceNV_ovr_2(vdpSurface, target, numTextureNames, textureNames);
private static function z_VDPAURegisterOutputSurfaceNV_ovr_0(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterOutputSurfaceNV';
private static function z_VDPAURegisterOutputSurfaceNV_ovr_0_anh00001(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterOutputSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32): GLvdpauSurfaceNV :=
if (textureNames<>nil) and (textureNames.Length<>0) then
z_VDPAURegisterOutputSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0]) else
z_VDPAURegisterOutputSurfaceNV_ovr_0_anh00001(vdpSurface, target, numTextureNames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV :=
z_VDPAURegisterOutputSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames);
private static function z_VDPAURegisterOutputSurfaceNV_ovr_2(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterOutputSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV :=
z_VDPAURegisterOutputSurfaceNV_ovr_2(vdpSurface, target, numTextureNames, textureNames);
private static function z_VDPAUIsSurfaceNV_ovr_0(surface: GLvdpauSurfaceNV): boolean;
external 'opengl32.dll' name 'glVDPAUIsSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAUIsSurfaceNV(surface: GLvdpauSurfaceNV): boolean :=
z_VDPAUIsSurfaceNV_ovr_0(surface);
private static procedure z_VDPAUUnregisterSurfaceNV_ovr_0(surface: GLvdpauSurfaceNV);
external 'opengl32.dll' name 'glVDPAUUnregisterSurfaceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnregisterSurfaceNV(surface: GLvdpauSurfaceNV) :=
z_VDPAUUnregisterSurfaceNV_ovr_0(surface);
private static procedure z_VDPAUGetSurfaceivNV_ovr_0(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; var values: Int32);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
private static procedure z_VDPAUGetSurfaceivNV_ovr_0_anh000010(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
private static procedure z_VDPAUGetSurfaceivNV_ovr_0_anh000001(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
private static procedure z_VDPAUGetSurfaceivNV_ovr_0_anh000011(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; values: array of Int32) :=
if (length<>nil) and (length.Length<>0) then
if (values<>nil) and (values.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length[0], values[0]) else
z_VDPAUGetSurfaceivNV_ovr_0_anh000001(surface, pname, count, length[0], IntPtr.Zero) else
if (values<>nil) and (values.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_0_anh000010(surface, pname, count, IntPtr.Zero, values[0]) else
z_VDPAUGetSurfaceivNV_ovr_0_anh000011(surface, pname, count, IntPtr.Zero, IntPtr.Zero);
private static procedure z_VDPAUGetSurfaceivNV_ovr_1_anh000010(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; var values: Int32) :=
if (length<>nil) and (length.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length[0], values) else
z_VDPAUGetSurfaceivNV_ovr_0_anh000010(surface, pname, count, IntPtr.Zero, values);
private static procedure z_VDPAUGetSurfaceivNV_ovr_2(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
private static procedure z_VDPAUGetSurfaceivNV_ovr_2_anh000010(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; values: IntPtr) :=
if (length<>nil) and (length.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_2(surface, pname, count, length[0], values) else
z_VDPAUGetSurfaceivNV_ovr_2_anh000010(surface, pname, count, IntPtr.Zero, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length, values[0]) else
z_VDPAUGetSurfaceivNV_ovr_0_anh000001(surface, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; var values: Int32) :=
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length, values);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: IntPtr) :=
z_VDPAUGetSurfaceivNV_ovr_2(surface, pname, count, length, values);
private static procedure z_VDPAUGetSurfaceivNV_ovr_6(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
private static procedure z_VDPAUGetSurfaceivNV_ovr_6_anh000001(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: array of Int32) :=
if (values<>nil) and (values.Length<>0) then
z_VDPAUGetSurfaceivNV_ovr_6(surface, pname, count, length, values[0]) else
z_VDPAUGetSurfaceivNV_ovr_6_anh000001(surface, pname, count, length, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32) :=
z_VDPAUGetSurfaceivNV_ovr_6(surface, pname, count, length, values);
private static procedure z_VDPAUGetSurfaceivNV_ovr_8(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr);
external 'opengl32.dll' name 'glVDPAUGetSurfaceivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr) :=
z_VDPAUGetSurfaceivNV_ovr_8(surface, pname, count, length, values);
private static procedure z_VDPAUSurfaceAccessNV_ovr_0(surface: GLvdpauSurfaceNV; access: DummyEnum);
external 'opengl32.dll' name 'glVDPAUSurfaceAccessNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUSurfaceAccessNV(surface: GLvdpauSurfaceNV; access: DummyEnum) :=
z_VDPAUSurfaceAccessNV_ovr_0(surface, access);
private static procedure z_VDPAUMapSurfacesNV_ovr_0(numSurfaces: Int32; var surfaces: GLvdpauSurfaceNV);
external 'opengl32.dll' name 'glVDPAUMapSurfacesNV';
private static procedure z_VDPAUMapSurfacesNV_ovr_0_anh001(numSurfaces: Int32; surfaces: IntPtr);
external 'opengl32.dll' name 'glVDPAUMapSurfacesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; surfaces: array of GLvdpauSurfaceNV) :=
if (surfaces<>nil) and (surfaces.Length<>0) then
z_VDPAUMapSurfacesNV_ovr_0(numSurfaces, surfaces[0]) else
z_VDPAUMapSurfacesNV_ovr_0_anh001(numSurfaces, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; var surfaces: GLvdpauSurfaceNV) :=
z_VDPAUMapSurfacesNV_ovr_0(numSurfaces, surfaces);
private static procedure z_VDPAUMapSurfacesNV_ovr_2(numSurfaces: Int32; surfaces: IntPtr);
external 'opengl32.dll' name 'glVDPAUMapSurfacesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; surfaces: IntPtr) :=
z_VDPAUMapSurfacesNV_ovr_2(numSurfaces, surfaces);
private static procedure z_VDPAUUnmapSurfacesNV_ovr_0(numSurface: Int32; var surfaces: GLvdpauSurfaceNV);
external 'opengl32.dll' name 'glVDPAUUnmapSurfacesNV';
private static procedure z_VDPAUUnmapSurfacesNV_ovr_0_anh001(numSurface: Int32; surfaces: IntPtr);
external 'opengl32.dll' name 'glVDPAUUnmapSurfacesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; surfaces: array of GLvdpauSurfaceNV) :=
if (surfaces<>nil) and (surfaces.Length<>0) then
z_VDPAUUnmapSurfacesNV_ovr_0(numSurface, surfaces[0]) else
z_VDPAUUnmapSurfacesNV_ovr_0_anh001(numSurface, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; var surfaces: GLvdpauSurfaceNV) :=
z_VDPAUUnmapSurfacesNV_ovr_0(numSurface, surfaces);
private static procedure z_VDPAUUnmapSurfacesNV_ovr_2(numSurface: Int32; surfaces: IntPtr);
external 'opengl32.dll' name 'glVDPAUUnmapSurfacesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; surfaces: IntPtr) :=
z_VDPAUUnmapSurfacesNV_ovr_2(numSurface, surfaces);
end;
[PCUNotRestore]
glVdpauInterop2NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceWithPictureStructureNV';
private static function z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0_anh000010(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr; isFrameStructure: boolean): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceWithPictureStructureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV :=
if (textureNames<>nil) and (textureNames.Length<>0) then
z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0], isFrameStructure) else
z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0_anh000010(vdpSurface, target, numTextureNames, IntPtr.Zero, isFrameStructure);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV :=
z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0(vdpSurface, target, numTextureNames, textureNames, isFrameStructure);
private static function z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_2(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr; isFrameStructure: boolean): GLvdpauSurfaceNV;
external 'opengl32.dll' name 'glVDPAURegisterVideoSurfaceWithPictureStructureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr; isFrameStructure: boolean): GLvdpauSurfaceNV :=
z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_2(vdpSurface, target, numTextureNames, textureNames, isFrameStructure);
end;
[PCUNotRestore]
glVertexArrayRangeNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FlushVertexArrayRangeNV_ovr_0;
external 'opengl32.dll' name 'glFlushVertexArrayRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushVertexArrayRangeNV :=
z_FlushVertexArrayRangeNV_ovr_0;
private static procedure z_VertexArrayRangeNV_ovr_0(length: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexArrayRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayRangeNV(length: Int32; pointer: IntPtr) :=
z_VertexArrayRangeNV_ovr_0(length, pointer);
end;
[PCUNotRestore]
glVertexAttribInteger64bitNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribL1i64NV_ovr_0(index: UInt32; x: Int64);
external 'opengl32.dll' name 'glVertexAttribL1i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64NV(index: UInt32; x: Int64) :=
z_VertexAttribL1i64NV_ovr_0(index, x);
private static procedure z_VertexAttribL2i64NV_ovr_0(index: UInt32; x: Int64; y: Int64);
external 'opengl32.dll' name 'glVertexAttribL2i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64NV(index: UInt32; x: Int64; y: Int64) :=
z_VertexAttribL2i64NV_ovr_0(index, x, y);
private static procedure z_VertexAttribL3i64NV_ovr_0(index: UInt32; x: Int64; y: Int64; z: Int64);
external 'opengl32.dll' name 'glVertexAttribL3i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64NV(index: UInt32; x: Int64; y: Int64; z: Int64) :=
z_VertexAttribL3i64NV_ovr_0(index, x, y, z);
private static procedure z_VertexAttribL4i64NV_ovr_0(index: UInt32; x: Int64; y: Int64; z: Int64; w: Int64);
external 'opengl32.dll' name 'glVertexAttribL4i64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64NV(index: UInt32; x: Int64; y: Int64; z: Int64; w: Int64) :=
z_VertexAttribL4i64NV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribL1i64vNV_ovr_0(index: UInt32; var v: Int64);
external 'opengl32.dll' name 'glVertexAttribL1i64vNV';
private static procedure z_VertexAttribL1i64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; v: array of Int64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1i64vNV_ovr_0(index, v[0]) else
z_VertexAttribL1i64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; var v: Int64) :=
z_VertexAttribL1i64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL1i64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL1i64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL2i64vNV_ovr_0(index: UInt32; var v: Int64);
external 'opengl32.dll' name 'glVertexAttribL2i64vNV';
private static procedure z_VertexAttribL2i64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; v: array of Int64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL2i64vNV_ovr_0(index, v[0]) else
z_VertexAttribL2i64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; var v: Int64) :=
z_VertexAttribL2i64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL2i64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL2i64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL3i64vNV_ovr_0(index: UInt32; var v: Int64);
external 'opengl32.dll' name 'glVertexAttribL3i64vNV';
private static procedure z_VertexAttribL3i64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; v: array of Int64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL3i64vNV_ovr_0(index, v[0]) else
z_VertexAttribL3i64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; var v: Int64) :=
z_VertexAttribL3i64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL3i64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL3i64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL4i64vNV_ovr_0(index: UInt32; var v: Int64);
external 'opengl32.dll' name 'glVertexAttribL4i64vNV';
private static procedure z_VertexAttribL4i64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; v: array of Int64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL4i64vNV_ovr_0(index, v[0]) else
z_VertexAttribL4i64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; var v: Int64) :=
z_VertexAttribL4i64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL4i64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4i64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL4i64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL1ui64NV_ovr_0(index: UInt32; x: UInt64);
external 'opengl32.dll' name 'glVertexAttribL1ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64NV(index: UInt32; x: UInt64) :=
z_VertexAttribL1ui64NV_ovr_0(index, x);
private static procedure z_VertexAttribL2ui64NV_ovr_0(index: UInt32; x: UInt64; y: UInt64);
external 'opengl32.dll' name 'glVertexAttribL2ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64NV(index: UInt32; x: UInt64; y: UInt64) :=
z_VertexAttribL2ui64NV_ovr_0(index, x, y);
private static procedure z_VertexAttribL3ui64NV_ovr_0(index: UInt32; x: UInt64; y: UInt64; z: UInt64);
external 'opengl32.dll' name 'glVertexAttribL3ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64NV(index: UInt32; x: UInt64; y: UInt64; z: UInt64) :=
z_VertexAttribL3ui64NV_ovr_0(index, x, y, z);
private static procedure z_VertexAttribL4ui64NV_ovr_0(index: UInt32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
external 'opengl32.dll' name 'glVertexAttribL4ui64NV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64NV(index: UInt32; x: UInt64; y: UInt64; z: UInt64; w: UInt64) :=
z_VertexAttribL4ui64NV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribL1ui64vNV_ovr_0(index: UInt32; var v: UInt64);
external 'opengl32.dll' name 'glVertexAttribL1ui64vNV';
private static procedure z_VertexAttribL1ui64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; v: array of UInt64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL1ui64vNV_ovr_0(index, v[0]) else
z_VertexAttribL1ui64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; var v: UInt64) :=
z_VertexAttribL1ui64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL1ui64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL1ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL1ui64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL2ui64vNV_ovr_0(index: UInt32; var v: UInt64);
external 'opengl32.dll' name 'glVertexAttribL2ui64vNV';
private static procedure z_VertexAttribL2ui64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; v: array of UInt64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL2ui64vNV_ovr_0(index, v[0]) else
z_VertexAttribL2ui64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; var v: UInt64) :=
z_VertexAttribL2ui64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL2ui64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL2ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL2ui64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL3ui64vNV_ovr_0(index: UInt32; var v: UInt64);
external 'opengl32.dll' name 'glVertexAttribL3ui64vNV';
private static procedure z_VertexAttribL3ui64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; v: array of UInt64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL3ui64vNV_ovr_0(index, v[0]) else
z_VertexAttribL3ui64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; var v: UInt64) :=
z_VertexAttribL3ui64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL3ui64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL3ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL3ui64vNV_ovr_2(index, v);
private static procedure z_VertexAttribL4ui64vNV_ovr_0(index: UInt32; var v: UInt64);
external 'opengl32.dll' name 'glVertexAttribL4ui64vNV';
private static procedure z_VertexAttribL4ui64vNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; v: array of UInt64) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribL4ui64vNV_ovr_0(index, v[0]) else
z_VertexAttribL4ui64vNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; var v: UInt64) :=
z_VertexAttribL4ui64vNV_ovr_0(index, v);
private static procedure z_VertexAttribL4ui64vNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribL4ui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; v: IntPtr) :=
z_VertexAttribL4ui64vNV_ovr_2(index, v);
private static procedure z_GetVertexAttribLi64vNV_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int64);
external 'opengl32.dll' name 'glGetVertexAttribLi64vNV';
private static procedure z_GetVertexAttribLi64vNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: array of Int64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLi64vNV_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLi64vNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int64) :=
z_GetVertexAttribLi64vNV_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribLi64vNV_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLi64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLi64vNV_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribLui64vNV_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64);
external 'opengl32.dll' name 'glGetVertexAttribLui64vNV';
private static procedure z_GetVertexAttribLui64vNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt64) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribLui64vNV_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribLui64vNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64) :=
z_GetVertexAttribLui64vNV_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribLui64vNV_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribLui64vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribLui64vNV_ovr_2(index, pname, ¶ms);
private static procedure z_VertexAttribLFormatNV_ovr_0(index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32);
external 'opengl32.dll' name 'glVertexAttribLFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLFormatNV(index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32) :=
z_VertexAttribLFormatNV_ovr_0(index, size, &type, stride);
end;
[PCUNotRestore]
glVertexBufferUnifiedMemoryNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BufferAddressRangeNV_ovr_0(pname: DummyEnum; index: UInt32; address: UInt64; length: IntPtr);
external 'opengl32.dll' name 'glBufferAddressRangeNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAddressRangeNV(pname: DummyEnum; index: UInt32; address: UInt64; length: IntPtr) :=
z_BufferAddressRangeNV_ovr_0(pname, index, address, length);
private static procedure z_VertexFormatNV_ovr_0(size: Int32; &type: VertexPointerType; stride: Int32);
external 'opengl32.dll' name 'glVertexFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexFormatNV(size: Int32; &type: VertexPointerType; stride: Int32) :=
z_VertexFormatNV_ovr_0(size, &type, stride);
private static procedure z_NormalFormatNV_ovr_0(&type: DummyEnum; stride: Int32);
external 'opengl32.dll' name 'glNormalFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalFormatNV(&type: DummyEnum; stride: Int32) :=
z_NormalFormatNV_ovr_0(&type, stride);
private static procedure z_ColorFormatNV_ovr_0(size: Int32; &type: DummyEnum; stride: Int32);
external 'opengl32.dll' name 'glColorFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFormatNV(size: Int32; &type: DummyEnum; stride: Int32) :=
z_ColorFormatNV_ovr_0(size, &type, stride);
private static procedure z_IndexFormatNV_ovr_0(&type: DummyEnum; stride: Int32);
external 'opengl32.dll' name 'glIndexFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexFormatNV(&type: DummyEnum; stride: Int32) :=
z_IndexFormatNV_ovr_0(&type, stride);
private static procedure z_TexCoordFormatNV_ovr_0(size: Int32; &type: DummyEnum; stride: Int32);
external 'opengl32.dll' name 'glTexCoordFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordFormatNV(size: Int32; &type: DummyEnum; stride: Int32) :=
z_TexCoordFormatNV_ovr_0(size, &type, stride);
private static procedure z_EdgeFlagFormatNV_ovr_0(stride: Int32);
external 'opengl32.dll' name 'glEdgeFlagFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagFormatNV(stride: Int32) :=
z_EdgeFlagFormatNV_ovr_0(stride);
private static procedure z_SecondaryColorFormatNV_ovr_0(size: Int32; &type: ColorPointerType; stride: Int32);
external 'opengl32.dll' name 'glSecondaryColorFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorFormatNV(size: Int32; &type: ColorPointerType; stride: Int32) :=
z_SecondaryColorFormatNV_ovr_0(size, &type, stride);
private static procedure z_FogCoordFormatNV_ovr_0(&type: DummyEnum; stride: Int32);
external 'opengl32.dll' name 'glFogCoordFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordFormatNV(&type: DummyEnum; stride: Int32) :=
z_FogCoordFormatNV_ovr_0(&type, stride);
private static procedure z_VertexAttribFormatNV_ovr_0(index: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; stride: Int32);
external 'opengl32.dll' name 'glVertexAttribFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribFormatNV(index: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; stride: Int32) :=
z_VertexAttribFormatNV_ovr_0(index, size, &type, normalized, stride);
private static procedure z_VertexAttribIFormatNV_ovr_0(index: UInt32; size: Int32; &type: VertexAttribIType; stride: Int32);
external 'opengl32.dll' name 'glVertexAttribIFormatNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIFormatNV(index: UInt32; size: Int32; &type: VertexAttribIType; stride: Int32) :=
z_VertexAttribIFormatNV_ovr_0(index, size, &type, stride);
private static procedure z_GetIntegerui64i_vNV_ovr_0(value: DummyEnum; index: UInt32; var result: UInt64);
external 'opengl32.dll' name 'glGetIntegerui64i_vNV';
private static procedure z_GetIntegerui64i_vNV_ovr_0_anh0001(value: DummyEnum; index: UInt32; result: IntPtr);
external 'opengl32.dll' name 'glGetIntegerui64i_vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; result: array of UInt64) :=
if (result<>nil) and (result.Length<>0) then
z_GetIntegerui64i_vNV_ovr_0(value, index, result[0]) else
z_GetIntegerui64i_vNV_ovr_0_anh0001(value, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; var result: UInt64) :=
z_GetIntegerui64i_vNV_ovr_0(value, index, result);
private static procedure z_GetIntegerui64i_vNV_ovr_2(value: DummyEnum; index: UInt32; result: IntPtr);
external 'opengl32.dll' name 'glGetIntegerui64i_vNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; result: IntPtr) :=
z_GetIntegerui64i_vNV_ovr_2(value, index, result);
end;
[PCUNotRestore]
glVertexProgramNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_AreProgramsResidentNV_ovr_0(n: Int32; var programs: UInt32; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
private static function z_AreProgramsResidentNV_ovr_0_anh0010(n: Int32; programs: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
private static function z_AreProgramsResidentNV_ovr_0_anh0001(n: Int32; var programs: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
private static function z_AreProgramsResidentNV_ovr_0_anh0011(n: Int32; programs: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; residences: array of boolean): boolean :=
if (programs<>nil) and (programs.Length<>0) then
if (residences<>nil) and (residences.Length<>0) then
z_AreProgramsResidentNV_ovr_0(n, programs[0], residences[0]) else
z_AreProgramsResidentNV_ovr_0_anh0001(n, programs[0], IntPtr.Zero) else
if (residences<>nil) and (residences.Length<>0) then
z_AreProgramsResidentNV_ovr_0_anh0010(n, IntPtr.Zero, residences[0]) else
z_AreProgramsResidentNV_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static function z_AreProgramsResidentNV_ovr_1_anh0010(n: Int32; programs: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; var residences: boolean): boolean :=
if (programs<>nil) and (programs.Length<>0) then
z_AreProgramsResidentNV_ovr_0(n, programs[0], residences) else
z_AreProgramsResidentNV_ovr_0_anh0010(n, IntPtr.Zero, residences);
private static function z_AreProgramsResidentNV_ovr_2(n: Int32; var programs: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
private static function z_AreProgramsResidentNV_ovr_2_anh0010(n: Int32; programs: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; residences: IntPtr): boolean :=
if (programs<>nil) and (programs.Length<>0) then
z_AreProgramsResidentNV_ovr_2(n, programs[0], residences) else
z_AreProgramsResidentNV_ovr_2_anh0010(n, IntPtr.Zero, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreProgramsResidentNV_ovr_0(n, programs, residences[0]) else
z_AreProgramsResidentNV_ovr_0_anh0001(n, programs, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; var residences: boolean): boolean :=
z_AreProgramsResidentNV_ovr_0(n, programs, residences);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; residences: IntPtr): boolean :=
z_AreProgramsResidentNV_ovr_2(n, programs, residences);
private static function z_AreProgramsResidentNV_ovr_6(n: Int32; programs: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
private static function z_AreProgramsResidentNV_ovr_6_anh0001(n: Int32; programs: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; residences: array of boolean): boolean :=
if (residences<>nil) and (residences.Length<>0) then
z_AreProgramsResidentNV_ovr_6(n, programs, residences[0]) else
z_AreProgramsResidentNV_ovr_6_anh0001(n, programs, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; var residences: boolean): boolean :=
z_AreProgramsResidentNV_ovr_6(n, programs, residences);
private static function z_AreProgramsResidentNV_ovr_8(n: Int32; programs: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreProgramsResidentNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; residences: IntPtr): boolean :=
z_AreProgramsResidentNV_ovr_8(n, programs, residences);
private static procedure z_BindProgramNV_ovr_0(target: VertexAttribEnumNV; id: UInt32);
external 'opengl32.dll' name 'glBindProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramNV(target: VertexAttribEnumNV; id: UInt32) :=
z_BindProgramNV_ovr_0(target, id);
private static procedure z_DeleteProgramsNV_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glDeleteProgramsNV';
private static procedure z_DeleteProgramsNV_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_DeleteProgramsNV_ovr_0(n, programs[0]) else
z_DeleteProgramsNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; var programs: UInt32) :=
z_DeleteProgramsNV_ovr_0(n, programs);
private static procedure z_DeleteProgramsNV_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glDeleteProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; programs: IntPtr) :=
z_DeleteProgramsNV_ovr_2(n, programs);
private static procedure z_ExecuteProgramNV_ovr_0(target: VertexAttribEnumNV; id: UInt32; var ¶ms: single);
external 'opengl32.dll' name 'glExecuteProgramNV';
private static procedure z_ExecuteProgramNV_ovr_0_anh0001(target: VertexAttribEnumNV; id: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glExecuteProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ExecuteProgramNV_ovr_0(target, id, ¶ms[0]) else
z_ExecuteProgramNV_ovr_0_anh0001(target, id, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; var ¶ms: single) :=
z_ExecuteProgramNV_ovr_0(target, id, ¶ms);
private static procedure z_ExecuteProgramNV_ovr_2(target: VertexAttribEnumNV; id: UInt32; ¶ms: IntPtr);
external 'opengl32.dll' name 'glExecuteProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; ¶ms: IntPtr) :=
z_ExecuteProgramNV_ovr_2(target, id, ¶ms);
private static procedure z_GenProgramsNV_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glGenProgramsNV';
private static procedure z_GenProgramsNV_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_GenProgramsNV_ovr_0(n, programs[0]) else
z_GenProgramsNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; var programs: UInt32) :=
z_GenProgramsNV_ovr_0(n, programs);
private static procedure z_GenProgramsNV_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glGenProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; programs: IntPtr) :=
z_GenProgramsNV_ovr_2(n, programs);
private static procedure z_GetProgramParameterdvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real);
external 'opengl32.dll' name 'glGetProgramParameterdvNV';
private static procedure z_GetProgramParameterdvNV_ovr_0_anh00001(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramParameterdvNV_ovr_0(target, index, pname, ¶ms[0]) else
z_GetProgramParameterdvNV_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real) :=
z_GetProgramParameterdvNV_ovr_0(target, index, pname, ¶ms);
private static procedure z_GetProgramParameterdvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetProgramParameterdvNV_ovr_2(target, index, pname, ¶ms);
private static procedure z_GetProgramParameterfvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetProgramParameterfvNV';
private static procedure z_GetProgramParameterfvNV_ovr_0_anh00001(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramParameterfvNV_ovr_0(target, index, pname, ¶ms[0]) else
z_GetProgramParameterfvNV_ovr_0_anh00001(target, index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single) :=
z_GetProgramParameterfvNV_ovr_0(target, index, pname, ¶ms);
private static procedure z_GetProgramParameterfvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetProgramParameterfvNV_ovr_2(target, index, pname, ¶ms);
private static procedure z_GetProgramivNV_ovr_0(id: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetProgramivNV';
private static procedure z_GetProgramivNV_ovr_0_anh0001(id: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetProgramivNV_ovr_0(id, pname, ¶ms[0]) else
z_GetProgramivNV_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32) :=
z_GetProgramivNV_ovr_0(id, pname, ¶ms);
private static procedure z_GetProgramivNV_ovr_2(id: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetProgramivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetProgramivNV_ovr_2(id, pname, ¶ms);
private static procedure z_GetProgramStringNV_ovr_0(id: UInt32; pname: VertexAttribEnumNV; var &program: Byte);
external 'opengl32.dll' name 'glGetProgramStringNV';
private static procedure z_GetProgramStringNV_ovr_0_anh0001(id: UInt32; pname: VertexAttribEnumNV; &program: IntPtr);
external 'opengl32.dll' name 'glGetProgramStringNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; &program: array of Byte) :=
if (&program<>nil) and (&program.Length<>0) then
z_GetProgramStringNV_ovr_0(id, pname, &program[0]) else
z_GetProgramStringNV_ovr_0_anh0001(id, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; var &program: Byte) :=
z_GetProgramStringNV_ovr_0(id, pname, &program);
private static procedure z_GetProgramStringNV_ovr_2(id: UInt32; pname: VertexAttribEnumNV; &program: IntPtr);
external 'opengl32.dll' name 'glGetProgramStringNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; &program: IntPtr) :=
z_GetProgramStringNV_ovr_2(id, pname, &program);
private static procedure z_GetTrackMatrixivNV_ovr_0(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTrackMatrixivNV';
private static procedure z_GetTrackMatrixivNV_ovr_0_anh00001(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTrackMatrixivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTrackMatrixivNV_ovr_0(target, address, pname, ¶ms[0]) else
z_GetTrackMatrixivNV_ovr_0_anh00001(target, address, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32) :=
z_GetTrackMatrixivNV_ovr_0(target, address, pname, ¶ms);
private static procedure z_GetTrackMatrixivNV_ovr_2(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTrackMatrixivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetTrackMatrixivNV_ovr_2(target, address, pname, ¶ms);
private static procedure z_GetVertexAttribdvNV_ovr_0(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real);
external 'opengl32.dll' name 'glGetVertexAttribdvNV';
private static procedure z_GetVertexAttribdvNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribdvNV_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribdvNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real) :=
z_GetVertexAttribdvNV_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribdvNV_ovr_2(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetVertexAttribdvNV_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvNV_ovr_0(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single);
external 'opengl32.dll' name 'glGetVertexAttribfvNV';
private static procedure z_GetVertexAttribfvNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribfvNV_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribfvNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single) :=
z_GetVertexAttribfvNV_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribfvNV_ovr_2(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetVertexAttribfvNV_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribivNV_ovr_0(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVertexAttribivNV';
private static procedure z_GetVertexAttribivNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribivNV_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribivNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32) :=
z_GetVertexAttribivNV_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribivNV_ovr_2(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr) :=
z_GetVertexAttribivNV_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribPointervNV_ovr_0(index: UInt32; pname: VertexAttribEnumNV; var _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervNV';
private static procedure z_GetVertexAttribPointervNV_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnumNV; _pointer: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribPointervNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_GetVertexAttribPointervNV_ovr_0(index, pname, _pointer[0]) else
z_GetVertexAttribPointervNV_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; var _pointer: IntPtr) :=
z_GetVertexAttribPointervNV_ovr_0(index, pname, _pointer);
private static procedure z_GetVertexAttribPointervNV_ovr_2(index: UInt32; pname: VertexAttribEnumNV; _pointer: pointer);
external 'opengl32.dll' name 'glGetVertexAttribPointervNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; _pointer: pointer) :=
z_GetVertexAttribPointervNV_ovr_2(index, pname, _pointer);
private static function z_IsProgramNV_ovr_0(id: UInt32): boolean;
external 'opengl32.dll' name 'glIsProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramNV(id: UInt32): boolean :=
z_IsProgramNV_ovr_0(id);
private static procedure z_LoadProgramNV_ovr_0(target: VertexAttribEnumNV; id: UInt32; len: Int32; var &program: Byte);
external 'opengl32.dll' name 'glLoadProgramNV';
private static procedure z_LoadProgramNV_ovr_0_anh00001(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: IntPtr);
external 'opengl32.dll' name 'glLoadProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: array of Byte) :=
if (&program<>nil) and (&program.Length<>0) then
z_LoadProgramNV_ovr_0(target, id, len, &program[0]) else
z_LoadProgramNV_ovr_0_anh00001(target, id, len, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; var &program: Byte) :=
z_LoadProgramNV_ovr_0(target, id, len, &program);
private static procedure z_LoadProgramNV_ovr_2(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: IntPtr);
external 'opengl32.dll' name 'glLoadProgramNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: IntPtr) :=
z_LoadProgramNV_ovr_2(target, id, len, &program);
private static procedure z_ProgramParameter4dNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glProgramParameter4dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dNV(target: VertexAttribEnumNV; index: UInt32; x: real; y: real; z: real; w: real) :=
z_ProgramParameter4dNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramParameter4dvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; var v: real);
external 'opengl32.dll' name 'glProgramParameter4dvNV';
private static procedure z_ProgramParameter4dvNV_ovr_0_anh0001(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramParameter4dvNV_ovr_0(target, index, v[0]) else
z_ProgramParameter4dvNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; var v: real) :=
z_ProgramParameter4dvNV_ovr_0(target, index, v);
private static procedure z_ProgramParameter4dvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameter4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; v: IntPtr) :=
z_ProgramParameter4dvNV_ovr_2(target, index, v);
private static procedure z_ProgramParameter4fNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glProgramParameter4fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fNV(target: VertexAttribEnumNV; index: UInt32; x: single; y: single; z: single; w: single) :=
z_ProgramParameter4fNV_ovr_0(target, index, x, y, z, w);
private static procedure z_ProgramParameter4fvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; var v: single);
external 'opengl32.dll' name 'glProgramParameter4fvNV';
private static procedure z_ProgramParameter4fvNV_ovr_0_anh0001(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramParameter4fvNV_ovr_0(target, index, v[0]) else
z_ProgramParameter4fvNV_ovr_0_anh0001(target, index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; var v: single) :=
z_ProgramParameter4fvNV_ovr_0(target, index, v);
private static procedure z_ProgramParameter4fvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameter4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; v: IntPtr) :=
z_ProgramParameter4fvNV_ovr_2(target, index, v);
private static procedure z_ProgramParameters4dvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glProgramParameters4dvNV';
private static procedure z_ProgramParameters4dvNV_ovr_0_anh00001(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameters4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramParameters4dvNV_ovr_0(target, index, count, v[0]) else
z_ProgramParameters4dvNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: real) :=
z_ProgramParameters4dvNV_ovr_0(target, index, count, v);
private static procedure z_ProgramParameters4dvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameters4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr) :=
z_ProgramParameters4dvNV_ovr_2(target, index, count, v);
private static procedure z_ProgramParameters4fvNV_ovr_0(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glProgramParameters4fvNV';
private static procedure z_ProgramParameters4fvNV_ovr_0_anh00001(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameters4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ProgramParameters4fvNV_ovr_0(target, index, count, v[0]) else
z_ProgramParameters4fvNV_ovr_0_anh00001(target, index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: single) :=
z_ProgramParameters4fvNV_ovr_0(target, index, count, v);
private static procedure z_ProgramParameters4fvNV_ovr_2(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glProgramParameters4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr) :=
z_ProgramParameters4fvNV_ovr_2(target, index, count, v);
private static procedure z_RequestResidentProgramsNV_ovr_0(n: Int32; var programs: UInt32);
external 'opengl32.dll' name 'glRequestResidentProgramsNV';
private static procedure z_RequestResidentProgramsNV_ovr_0_anh001(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glRequestResidentProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; programs: array of UInt32) :=
if (programs<>nil) and (programs.Length<>0) then
z_RequestResidentProgramsNV_ovr_0(n, programs[0]) else
z_RequestResidentProgramsNV_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; var programs: UInt32) :=
z_RequestResidentProgramsNV_ovr_0(n, programs);
private static procedure z_RequestResidentProgramsNV_ovr_2(n: Int32; programs: IntPtr);
external 'opengl32.dll' name 'glRequestResidentProgramsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; programs: IntPtr) :=
z_RequestResidentProgramsNV_ovr_2(n, programs);
private static procedure z_TrackMatrixNV_ovr_0(target: VertexAttribEnumNV; address: UInt32; matrix: VertexAttribEnumNV; transform: VertexAttribEnumNV);
external 'opengl32.dll' name 'glTrackMatrixNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TrackMatrixNV(target: VertexAttribEnumNV; address: UInt32; matrix: VertexAttribEnumNV; transform: VertexAttribEnumNV) :=
z_TrackMatrixNV_ovr_0(target, address, matrix, transform);
private static procedure z_VertexAttribPointerNV_ovr_0(index: UInt32; fsize: Int32; &type: VertexAttribEnumNV; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribPointerNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerNV(index: UInt32; fsize: Int32; &type: VertexAttribEnumNV; stride: Int32; pointer: IntPtr) :=
z_VertexAttribPointerNV_ovr_0(index, fsize, &type, stride, pointer);
private static procedure z_VertexAttrib1dNV_ovr_0(index: UInt32; x: real);
external 'opengl32.dll' name 'glVertexAttrib1dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dNV(index: UInt32; x: real) :=
z_VertexAttrib1dNV_ovr_0(index, x);
private static procedure z_VertexAttrib1dvNV_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib1dvNV';
private static procedure z_VertexAttrib1dvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1dvNV_ovr_0(index, v[0]) else
z_VertexAttrib1dvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; var v: real) :=
z_VertexAttrib1dvNV_ovr_0(index, v);
private static procedure z_VertexAttrib1dvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib1dvNV_ovr_2(index, v);
private static procedure z_VertexAttrib1fNV_ovr_0(index: UInt32; x: single);
external 'opengl32.dll' name 'glVertexAttrib1fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fNV(index: UInt32; x: single) :=
z_VertexAttrib1fNV_ovr_0(index, x);
private static procedure z_VertexAttrib1fvNV_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib1fvNV';
private static procedure z_VertexAttrib1fvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1fvNV_ovr_0(index, v[0]) else
z_VertexAttrib1fvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; var v: single) :=
z_VertexAttrib1fvNV_ovr_0(index, v);
private static procedure z_VertexAttrib1fvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib1fvNV_ovr_2(index, v);
private static procedure z_VertexAttrib1sNV_ovr_0(index: UInt32; x: Int16);
external 'opengl32.dll' name 'glVertexAttrib1sNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sNV(index: UInt32; x: Int16) :=
z_VertexAttrib1sNV_ovr_0(index, x);
private static procedure z_VertexAttrib1svNV_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib1svNV';
private static procedure z_VertexAttrib1svNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib1svNV_ovr_0(index, v[0]) else
z_VertexAttrib1svNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; var v: Int16) :=
z_VertexAttrib1svNV_ovr_0(index, v);
private static procedure z_VertexAttrib1svNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib1svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib1svNV_ovr_2(index, v);
private static procedure z_VertexAttrib2dNV_ovr_0(index: UInt32; x: real; y: real);
external 'opengl32.dll' name 'glVertexAttrib2dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dNV(index: UInt32; x: real; y: real) :=
z_VertexAttrib2dNV_ovr_0(index, x, y);
private static procedure z_VertexAttrib2dvNV_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib2dvNV';
private static procedure z_VertexAttrib2dvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2dvNV_ovr_0(index, v[0]) else
z_VertexAttrib2dvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; var v: real) :=
z_VertexAttrib2dvNV_ovr_0(index, v);
private static procedure z_VertexAttrib2dvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib2dvNV_ovr_2(index, v);
private static procedure z_VertexAttrib2fNV_ovr_0(index: UInt32; x: single; y: single);
external 'opengl32.dll' name 'glVertexAttrib2fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fNV(index: UInt32; x: single; y: single) :=
z_VertexAttrib2fNV_ovr_0(index, x, y);
private static procedure z_VertexAttrib2fvNV_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib2fvNV';
private static procedure z_VertexAttrib2fvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2fvNV_ovr_0(index, v[0]) else
z_VertexAttrib2fvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; var v: single) :=
z_VertexAttrib2fvNV_ovr_0(index, v);
private static procedure z_VertexAttrib2fvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib2fvNV_ovr_2(index, v);
private static procedure z_VertexAttrib2sNV_ovr_0(index: UInt32; x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertexAttrib2sNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sNV(index: UInt32; x: Int16; y: Int16) :=
z_VertexAttrib2sNV_ovr_0(index, x, y);
private static procedure z_VertexAttrib2svNV_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib2svNV';
private static procedure z_VertexAttrib2svNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib2svNV_ovr_0(index, v[0]) else
z_VertexAttrib2svNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; var v: Int16) :=
z_VertexAttrib2svNV_ovr_0(index, v);
private static procedure z_VertexAttrib2svNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib2svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib2svNV_ovr_2(index, v);
private static procedure z_VertexAttrib3dNV_ovr_0(index: UInt32; x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertexAttrib3dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dNV(index: UInt32; x: real; y: real; z: real) :=
z_VertexAttrib3dNV_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3dvNV_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib3dvNV';
private static procedure z_VertexAttrib3dvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3dvNV_ovr_0(index, v[0]) else
z_VertexAttrib3dvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; var v: real) :=
z_VertexAttrib3dvNV_ovr_0(index, v);
private static procedure z_VertexAttrib3dvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib3dvNV_ovr_2(index, v);
private static procedure z_VertexAttrib3fNV_ovr_0(index: UInt32; x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertexAttrib3fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fNV(index: UInt32; x: single; y: single; z: single) :=
z_VertexAttrib3fNV_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3fvNV_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib3fvNV';
private static procedure z_VertexAttrib3fvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3fvNV_ovr_0(index, v[0]) else
z_VertexAttrib3fvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; var v: single) :=
z_VertexAttrib3fvNV_ovr_0(index, v);
private static procedure z_VertexAttrib3fvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib3fvNV_ovr_2(index, v);
private static procedure z_VertexAttrib3sNV_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertexAttrib3sNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sNV(index: UInt32; x: Int16; y: Int16; z: Int16) :=
z_VertexAttrib3sNV_ovr_0(index, x, y, z);
private static procedure z_VertexAttrib3svNV_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib3svNV';
private static procedure z_VertexAttrib3svNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib3svNV_ovr_0(index, v[0]) else
z_VertexAttrib3svNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; var v: Int16) :=
z_VertexAttrib3svNV_ovr_0(index, v);
private static procedure z_VertexAttrib3svNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib3svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib3svNV_ovr_2(index, v);
private static procedure z_VertexAttrib4dNV_ovr_0(index: UInt32; x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertexAttrib4dNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dNV(index: UInt32; x: real; y: real; z: real; w: real) :=
z_VertexAttrib4dNV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4dvNV_ovr_0(index: UInt32; var v: real);
external 'opengl32.dll' name 'glVertexAttrib4dvNV';
private static procedure z_VertexAttrib4dvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4dvNV_ovr_0(index, v[0]) else
z_VertexAttrib4dvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; var v: real) :=
z_VertexAttrib4dvNV_ovr_0(index, v);
private static procedure z_VertexAttrib4dvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib4dvNV_ovr_2(index, v);
private static procedure z_VertexAttrib4fNV_ovr_0(index: UInt32; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertexAttrib4fNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fNV(index: UInt32; x: single; y: single; z: single; w: single) :=
z_VertexAttrib4fNV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4fvNV_ovr_0(index: UInt32; var v: single);
external 'opengl32.dll' name 'glVertexAttrib4fvNV';
private static procedure z_VertexAttrib4fvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4fvNV_ovr_0(index, v[0]) else
z_VertexAttrib4fvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; var v: single) :=
z_VertexAttrib4fvNV_ovr_0(index, v);
private static procedure z_VertexAttrib4fvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib4fvNV_ovr_2(index, v);
private static procedure z_VertexAttrib4sNV_ovr_0(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertexAttrib4sNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sNV(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16) :=
z_VertexAttrib4sNV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4svNV_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttrib4svNV';
private static procedure z_VertexAttrib4svNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4svNV_ovr_0(index, v[0]) else
z_VertexAttrib4svNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; var v: Int16) :=
z_VertexAttrib4svNV_ovr_0(index, v);
private static procedure z_VertexAttrib4svNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib4svNV_ovr_2(index, v);
private static procedure z_VertexAttrib4ubNV_ovr_0(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
external 'opengl32.dll' name 'glVertexAttrib4ubNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubNV(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte) :=
z_VertexAttrib4ubNV_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttrib4ubvNV_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttrib4ubvNV';
private static procedure z_VertexAttrib4ubvNV_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttrib4ubvNV_ovr_0(index, v[0]) else
z_VertexAttrib4ubvNV_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; var v: Byte) :=
z_VertexAttrib4ubvNV_ovr_0(index, v);
private static procedure z_VertexAttrib4ubvNV_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttrib4ubvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; v: IntPtr) :=
z_VertexAttrib4ubvNV_ovr_2(index, v);
private static procedure z_VertexAttribs1dvNV_ovr_0(index: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glVertexAttribs1dvNV';
private static procedure z_VertexAttribs1dvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs1dvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs1dvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; var v: real) :=
z_VertexAttribs1dvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs1dvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs1dvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs1fvNV_ovr_0(index: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glVertexAttribs1fvNV';
private static procedure z_VertexAttribs1fvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs1fvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs1fvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; var v: single) :=
z_VertexAttribs1fvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs1fvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs1fvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs1svNV_ovr_0(index: UInt32; count: Int32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttribs1svNV';
private static procedure z_VertexAttribs1svNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs1svNV_ovr_0(index, count, v[0]) else
z_VertexAttribs1svNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; var v: Int16) :=
z_VertexAttribs1svNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs1svNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs1svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs1svNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs2dvNV_ovr_0(index: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glVertexAttribs2dvNV';
private static procedure z_VertexAttribs2dvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs2dvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs2dvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; var v: real) :=
z_VertexAttribs2dvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs2dvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs2dvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs2fvNV_ovr_0(index: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glVertexAttribs2fvNV';
private static procedure z_VertexAttribs2fvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs2fvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs2fvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; var v: single) :=
z_VertexAttribs2fvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs2fvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs2fvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs2svNV_ovr_0(index: UInt32; count: Int32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttribs2svNV';
private static procedure z_VertexAttribs2svNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs2svNV_ovr_0(index, count, v[0]) else
z_VertexAttribs2svNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; var v: Int16) :=
z_VertexAttribs2svNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs2svNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs2svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs2svNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs3dvNV_ovr_0(index: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glVertexAttribs3dvNV';
private static procedure z_VertexAttribs3dvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs3dvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs3dvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; var v: real) :=
z_VertexAttribs3dvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs3dvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs3dvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs3fvNV_ovr_0(index: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glVertexAttribs3fvNV';
private static procedure z_VertexAttribs3fvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs3fvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs3fvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; var v: single) :=
z_VertexAttribs3fvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs3fvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs3fvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs3svNV_ovr_0(index: UInt32; count: Int32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttribs3svNV';
private static procedure z_VertexAttribs3svNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs3svNV_ovr_0(index, count, v[0]) else
z_VertexAttribs3svNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; var v: Int16) :=
z_VertexAttribs3svNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs3svNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs3svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs3svNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs4dvNV_ovr_0(index: UInt32; count: Int32; var v: real);
external 'opengl32.dll' name 'glVertexAttribs4dvNV';
private static procedure z_VertexAttribs4dvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; v: array of real) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs4dvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs4dvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; var v: real) :=
z_VertexAttribs4dvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs4dvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4dvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs4dvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs4fvNV_ovr_0(index: UInt32; count: Int32; var v: single);
external 'opengl32.dll' name 'glVertexAttribs4fvNV';
private static procedure z_VertexAttribs4fvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs4fvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs4fvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; var v: single) :=
z_VertexAttribs4fvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs4fvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4fvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs4fvNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs4svNV_ovr_0(index: UInt32; count: Int32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttribs4svNV';
private static procedure z_VertexAttribs4svNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs4svNV_ovr_0(index, count, v[0]) else
z_VertexAttribs4svNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; var v: Int16) :=
z_VertexAttribs4svNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs4svNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4svNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs4svNV_ovr_2(index, count, v);
private static procedure z_VertexAttribs4ubvNV_ovr_0(index: UInt32; count: Int32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttribs4ubvNV';
private static procedure z_VertexAttribs4ubvNV_ovr_0_anh0001(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4ubvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribs4ubvNV_ovr_0(index, count, v[0]) else
z_VertexAttribs4ubvNV_ovr_0_anh0001(index, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; var v: Byte) :=
z_VertexAttribs4ubvNV_ovr_0(index, count, v);
private static procedure z_VertexAttribs4ubvNV_ovr_2(index: UInt32; count: Int32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribs4ubvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; v: IntPtr) :=
z_VertexAttribs4ubvNV_ovr_2(index, count, v);
end;
[PCUNotRestore]
glVertexProgram4NV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_VertexAttribI1iEXT_ovr_0(index: UInt32; x: Int32);
external 'opengl32.dll' name 'glVertexAttribI1iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iEXT(index: UInt32; x: Int32) :=
z_VertexAttribI1iEXT_ovr_0(index, x);
private static procedure z_VertexAttribI2iEXT_ovr_0(index: UInt32; x: Int32; y: Int32);
external 'opengl32.dll' name 'glVertexAttribI2iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iEXT(index: UInt32; x: Int32; y: Int32) :=
z_VertexAttribI2iEXT_ovr_0(index, x, y);
private static procedure z_VertexAttribI3iEXT_ovr_0(index: UInt32; x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glVertexAttribI3iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iEXT(index: UInt32; x: Int32; y: Int32; z: Int32) :=
z_VertexAttribI3iEXT_ovr_0(index, x, y, z);
private static procedure z_VertexAttribI4iEXT_ovr_0(index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glVertexAttribI4iEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iEXT(index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32) :=
z_VertexAttribI4iEXT_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribI1uiEXT_ovr_0(index: UInt32; x: UInt32);
external 'opengl32.dll' name 'glVertexAttribI1uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiEXT(index: UInt32; x: UInt32) :=
z_VertexAttribI1uiEXT_ovr_0(index, x);
private static procedure z_VertexAttribI2uiEXT_ovr_0(index: UInt32; x: UInt32; y: UInt32);
external 'opengl32.dll' name 'glVertexAttribI2uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiEXT(index: UInt32; x: UInt32; y: UInt32) :=
z_VertexAttribI2uiEXT_ovr_0(index, x, y);
private static procedure z_VertexAttribI3uiEXT_ovr_0(index: UInt32; x: UInt32; y: UInt32; z: UInt32);
external 'opengl32.dll' name 'glVertexAttribI3uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiEXT(index: UInt32; x: UInt32; y: UInt32; z: UInt32) :=
z_VertexAttribI3uiEXT_ovr_0(index, x, y, z);
private static procedure z_VertexAttribI4uiEXT_ovr_0(index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
external 'opengl32.dll' name 'glVertexAttribI4uiEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiEXT(index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32) :=
z_VertexAttribI4uiEXT_ovr_0(index, x, y, z, w);
private static procedure z_VertexAttribI1ivEXT_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttribI1ivEXT';
private static procedure z_VertexAttribI1ivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI1ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1ivEXT(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI1ivEXT_ovr_0(index, v[0]) else
z_VertexAttribI1ivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1ivEXT(index: UInt32; var v: Int32) :=
z_VertexAttribI1ivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI1ivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI1ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1ivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI1ivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI2ivEXT_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttribI2ivEXT';
private static procedure z_VertexAttribI2ivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI2ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2ivEXT(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI2ivEXT_ovr_0(index, v[0]) else
z_VertexAttribI2ivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2ivEXT(index: UInt32; var v: Int32) :=
z_VertexAttribI2ivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI2ivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI2ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2ivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI2ivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI3ivEXT_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttribI3ivEXT';
private static procedure z_VertexAttribI3ivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3ivEXT(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI3ivEXT_ovr_0(index, v[0]) else
z_VertexAttribI3ivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3ivEXT(index: UInt32; var v: Int32) :=
z_VertexAttribI3ivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI3ivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI3ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3ivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI3ivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4ivEXT_ovr_0(index: UInt32; var v: Int32);
external 'opengl32.dll' name 'glVertexAttribI4ivEXT';
private static procedure z_VertexAttribI4ivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ivEXT(index: UInt32; v: array of Int32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4ivEXT_ovr_0(index, v[0]) else
z_VertexAttribI4ivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ivEXT(index: UInt32; var v: Int32) :=
z_VertexAttribI4ivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4ivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4ivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4ivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI1uivEXT_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttribI1uivEXT';
private static procedure z_VertexAttribI1uivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uivEXT(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI1uivEXT_ovr_0(index, v[0]) else
z_VertexAttribI1uivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uivEXT(index: UInt32; var v: UInt32) :=
z_VertexAttribI1uivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI1uivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI1uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI1uivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI2uivEXT_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttribI2uivEXT';
private static procedure z_VertexAttribI2uivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uivEXT(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI2uivEXT_ovr_0(index, v[0]) else
z_VertexAttribI2uivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uivEXT(index: UInt32; var v: UInt32) :=
z_VertexAttribI2uivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI2uivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI2uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI2uivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI3uivEXT_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttribI3uivEXT';
private static procedure z_VertexAttribI3uivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uivEXT(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI3uivEXT_ovr_0(index, v[0]) else
z_VertexAttribI3uivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uivEXT(index: UInt32; var v: UInt32) :=
z_VertexAttribI3uivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI3uivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI3uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI3uivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4uivEXT_ovr_0(index: UInt32; var v: UInt32);
external 'opengl32.dll' name 'glVertexAttribI4uivEXT';
private static procedure z_VertexAttribI4uivEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uivEXT(index: UInt32; v: array of UInt32) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4uivEXT_ovr_0(index, v[0]) else
z_VertexAttribI4uivEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uivEXT(index: UInt32; var v: UInt32) :=
z_VertexAttribI4uivEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4uivEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4uivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uivEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4uivEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4bvEXT_ovr_0(index: UInt32; var v: SByte);
external 'opengl32.dll' name 'glVertexAttribI4bvEXT';
private static procedure z_VertexAttribI4bvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bvEXT(index: UInt32; v: array of SByte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4bvEXT_ovr_0(index, v[0]) else
z_VertexAttribI4bvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bvEXT(index: UInt32; var v: SByte) :=
z_VertexAttribI4bvEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4bvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4bvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4bvEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4svEXT_ovr_0(index: UInt32; var v: Int16);
external 'opengl32.dll' name 'glVertexAttribI4svEXT';
private static procedure z_VertexAttribI4svEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4svEXT(index: UInt32; v: array of Int16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4svEXT_ovr_0(index, v[0]) else
z_VertexAttribI4svEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4svEXT(index: UInt32; var v: Int16) :=
z_VertexAttribI4svEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4svEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4svEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4svEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4svEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4ubvEXT_ovr_0(index: UInt32; var v: Byte);
external 'opengl32.dll' name 'glVertexAttribI4ubvEXT';
private static procedure z_VertexAttribI4ubvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4ubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubvEXT(index: UInt32; v: array of Byte) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4ubvEXT_ovr_0(index, v[0]) else
z_VertexAttribI4ubvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubvEXT(index: UInt32; var v: Byte) :=
z_VertexAttribI4ubvEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4ubvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4ubvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4ubvEXT_ovr_2(index, v);
private static procedure z_VertexAttribI4usvEXT_ovr_0(index: UInt32; var v: UInt16);
external 'opengl32.dll' name 'glVertexAttribI4usvEXT';
private static procedure z_VertexAttribI4usvEXT_ovr_0_anh001(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4usvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usvEXT(index: UInt32; v: array of UInt16) :=
if (v<>nil) and (v.Length<>0) then
z_VertexAttribI4usvEXT_ovr_0(index, v[0]) else
z_VertexAttribI4usvEXT_ovr_0_anh001(index, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usvEXT(index: UInt32; var v: UInt16) :=
z_VertexAttribI4usvEXT_ovr_0(index, v);
private static procedure z_VertexAttribI4usvEXT_ovr_2(index: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glVertexAttribI4usvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usvEXT(index: UInt32; v: IntPtr) :=
z_VertexAttribI4usvEXT_ovr_2(index, v);
private static procedure z_VertexAttribIPointerEXT_ovr_0(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexAttribIPointerEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIPointerEXT(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr) :=
z_VertexAttribIPointerEXT_ovr_0(index, size, &type, stride, pointer);
private static procedure z_GetVertexAttribIivEXT_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVertexAttribIivEXT';
private static procedure z_GetVertexAttribIivEXT_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIivEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribIivEXT_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribIivEXT_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIivEXT(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32) :=
z_GetVertexAttribIivEXT_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribIivEXT_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribIivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIivEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribIivEXT_ovr_2(index, pname, ¶ms);
private static procedure z_GetVertexAttribIuivEXT_ovr_0(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32);
external 'opengl32.dll' name 'glGetVertexAttribIuivEXT';
private static procedure z_GetVertexAttribIuivEXT_ovr_0_anh0001(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuivEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVertexAttribIuivEXT_ovr_0(index, pname, ¶ms[0]) else
z_GetVertexAttribIuivEXT_ovr_0_anh0001(index, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuivEXT(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32) :=
z_GetVertexAttribIuivEXT_ovr_0(index, pname, ¶ms);
private static procedure z_GetVertexAttribIuivEXT_ovr_2(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVertexAttribIuivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuivEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr) :=
z_GetVertexAttribIuivEXT_ovr_2(index, pname, ¶ms);
end;
[PCUNotRestore]
glVideoCaptureNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_BeginVideoCaptureNV_ovr_0(video_capture_slot: UInt32);
external 'opengl32.dll' name 'glBeginVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginVideoCaptureNV(video_capture_slot: UInt32) :=
z_BeginVideoCaptureNV_ovr_0(video_capture_slot);
private static procedure z_BindVideoCaptureStreamBufferNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; offset: IntPtr);
external 'opengl32.dll' name 'glBindVideoCaptureStreamBufferNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVideoCaptureStreamBufferNV(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; offset: IntPtr) :=
z_BindVideoCaptureStreamBufferNV_ovr_0(video_capture_slot, stream, frame_region, offset);
private static procedure z_BindVideoCaptureStreamTextureNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; target: DummyEnum; texture: UInt32);
external 'opengl32.dll' name 'glBindVideoCaptureStreamTextureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVideoCaptureStreamTextureNV(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; target: DummyEnum; texture: UInt32) :=
z_BindVideoCaptureStreamTextureNV_ovr_0(video_capture_slot, stream, frame_region, target, texture);
private static procedure z_EndVideoCaptureNV_ovr_0(video_capture_slot: UInt32);
external 'opengl32.dll' name 'glEndVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndVideoCaptureNV(video_capture_slot: UInt32) :=
z_EndVideoCaptureNV_ovr_0(video_capture_slot);
private static procedure z_GetVideoCaptureivNV_ovr_0(video_capture_slot: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVideoCaptureivNV';
private static procedure z_GetVideoCaptureivNV_ovr_0_anh0001(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoCaptureivNV_ovr_0(video_capture_slot, pname, ¶ms[0]) else
z_GetVideoCaptureivNV_ovr_0_anh0001(video_capture_slot, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_GetVideoCaptureivNV_ovr_0(video_capture_slot, pname, ¶ms);
private static procedure z_GetVideoCaptureivNV_ovr_2(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoCaptureivNV_ovr_2(video_capture_slot, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamivNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetVideoCaptureStreamivNV';
private static procedure z_GetVideoCaptureStreamivNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoCaptureStreamivNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_GetVideoCaptureStreamivNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_GetVideoCaptureStreamivNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamivNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoCaptureStreamivNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamfvNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single);
external 'opengl32.dll' name 'glGetVideoCaptureStreamfvNV';
private static procedure z_GetVideoCaptureStreamfvNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoCaptureStreamfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_GetVideoCaptureStreamfvNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single) :=
z_GetVideoCaptureStreamfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamfvNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoCaptureStreamfvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamdvNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real);
external 'opengl32.dll' name 'glGetVideoCaptureStreamdvNV';
private static procedure z_GetVideoCaptureStreamdvNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetVideoCaptureStreamdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_GetVideoCaptureStreamdvNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real) :=
z_GetVideoCaptureStreamdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_GetVideoCaptureStreamdvNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetVideoCaptureStreamdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetVideoCaptureStreamdvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
private static function z_VideoCaptureNV_ovr_0(video_capture_slot: UInt32; var sequence_num: UInt32; var capture_time: UInt64): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
private static function z_VideoCaptureNV_ovr_0_anh0010(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
private static function z_VideoCaptureNV_ovr_0_anh0001(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
private static function z_VideoCaptureNV_ovr_0_anh0011(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; capture_time: array of UInt64): DummyEnum :=
if (sequence_num<>nil) and (sequence_num.Length<>0) then
if (capture_time<>nil) and (capture_time.Length<>0) then
z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num[0], capture_time[0]) else
z_VideoCaptureNV_ovr_0_anh0001(video_capture_slot, sequence_num[0], IntPtr.Zero) else
if (capture_time<>nil) and (capture_time.Length<>0) then
z_VideoCaptureNV_ovr_0_anh0010(video_capture_slot, IntPtr.Zero, capture_time[0]) else
z_VideoCaptureNV_ovr_0_anh0011(video_capture_slot, IntPtr.Zero, IntPtr.Zero);
private static function z_VideoCaptureNV_ovr_1_anh0010(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; var capture_time: UInt64): DummyEnum :=
if (sequence_num<>nil) and (sequence_num.Length<>0) then
z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num[0], capture_time) else
z_VideoCaptureNV_ovr_0_anh0010(video_capture_slot, IntPtr.Zero, capture_time);
private static function z_VideoCaptureNV_ovr_2(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
private static function z_VideoCaptureNV_ovr_2_anh0010(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; capture_time: IntPtr): DummyEnum :=
if (sequence_num<>nil) and (sequence_num.Length<>0) then
z_VideoCaptureNV_ovr_2(video_capture_slot, sequence_num[0], capture_time) else
z_VideoCaptureNV_ovr_2_anh0010(video_capture_slot, IntPtr.Zero, capture_time);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: array of UInt64): DummyEnum :=
if (capture_time<>nil) and (capture_time.Length<>0) then
z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num, capture_time[0]) else
z_VideoCaptureNV_ovr_0_anh0001(video_capture_slot, sequence_num, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; var capture_time: UInt64): DummyEnum :=
z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num, capture_time);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: IntPtr): DummyEnum :=
z_VideoCaptureNV_ovr_2(video_capture_slot, sequence_num, capture_time);
private static function z_VideoCaptureNV_ovr_6(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
private static function z_VideoCaptureNV_ovr_6_anh0001(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: array of UInt64): DummyEnum :=
if (capture_time<>nil) and (capture_time.Length<>0) then
z_VideoCaptureNV_ovr_6(video_capture_slot, sequence_num, capture_time[0]) else
z_VideoCaptureNV_ovr_6_anh0001(video_capture_slot, sequence_num, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum :=
z_VideoCaptureNV_ovr_6(video_capture_slot, sequence_num, capture_time);
private static function z_VideoCaptureNV_ovr_8(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum;
external 'opengl32.dll' name 'glVideoCaptureNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum :=
z_VideoCaptureNV_ovr_8(video_capture_slot, sequence_num, capture_time);
private static procedure z_VideoCaptureStreamParameterivNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterivNV';
private static procedure z_VideoCaptureStreamParameterivNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_VideoCaptureStreamParameterivNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_VideoCaptureStreamParameterivNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32) :=
z_VideoCaptureStreamParameterivNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_VideoCaptureStreamParameterivNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterivNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_VideoCaptureStreamParameterivNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
private static procedure z_VideoCaptureStreamParameterfvNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterfvNV';
private static procedure z_VideoCaptureStreamParameterfvNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_VideoCaptureStreamParameterfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_VideoCaptureStreamParameterfvNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single) :=
z_VideoCaptureStreamParameterfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_VideoCaptureStreamParameterfvNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterfvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_VideoCaptureStreamParameterfvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
private static procedure z_VideoCaptureStreamParameterdvNV_ovr_0(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterdvNV';
private static procedure z_VideoCaptureStreamParameterdvNV_ovr_0_anh00001(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of real) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_VideoCaptureStreamParameterdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]) else
z_VideoCaptureStreamParameterdvNV_ovr_0_anh00001(video_capture_slot, stream, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real) :=
z_VideoCaptureStreamParameterdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
private static procedure z_VideoCaptureStreamParameterdvNV_ovr_2(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glVideoCaptureStreamParameterdvNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr) :=
z_VideoCaptureStreamParameterdvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
[PCUNotRestore]
glViewportSwizzleNV = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ViewportSwizzleNV_ovr_0(index: UInt32; swizzlex: DummyEnum; swizzley: DummyEnum; swizzlez: DummyEnum; swizzlew: DummyEnum);
external 'opengl32.dll' name 'glViewportSwizzleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportSwizzleNV(index: UInt32; swizzlex: DummyEnum; swizzley: DummyEnum; swizzlez: DummyEnum; swizzlew: DummyEnum) :=
z_ViewportSwizzleNV_ovr_0(index, swizzlex, swizzley, swizzlez, swizzlew);
end;
[PCUNotRestore]
glByteCoordinatesOES = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_MultiTexCoord1bOES_ovr_0(texture: TextureUnit; s: SByte);
external 'opengl32.dll' name 'glMultiTexCoord1bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bOES(texture: TextureUnit; s: SByte) :=
z_MultiTexCoord1bOES_ovr_0(texture, s);
private static procedure z_MultiTexCoord1bvOES_ovr_0(texture: TextureUnit; var coords: SByte);
external 'opengl32.dll' name 'glMultiTexCoord1bvOES';
private static procedure z_MultiTexCoord1bvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord1bvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord1bvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; var coords: SByte) :=
z_MultiTexCoord1bvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord1bvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord1bvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord2bOES_ovr_0(texture: TextureUnit; s: SByte; t: SByte);
external 'opengl32.dll' name 'glMultiTexCoord2bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bOES(texture: TextureUnit; s: SByte; t: SByte) :=
z_MultiTexCoord2bOES_ovr_0(texture, s, t);
private static procedure z_MultiTexCoord2bvOES_ovr_0(texture: TextureUnit; var coords: SByte);
external 'opengl32.dll' name 'glMultiTexCoord2bvOES';
private static procedure z_MultiTexCoord2bvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord2bvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord2bvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; var coords: SByte) :=
z_MultiTexCoord2bvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord2bvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord2bvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord3bOES_ovr_0(texture: TextureUnit; s: SByte; t: SByte; r: SByte);
external 'opengl32.dll' name 'glMultiTexCoord3bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bOES(texture: TextureUnit; s: SByte; t: SByte; r: SByte) :=
z_MultiTexCoord3bOES_ovr_0(texture, s, t, r);
private static procedure z_MultiTexCoord3bvOES_ovr_0(texture: TextureUnit; var coords: SByte);
external 'opengl32.dll' name 'glMultiTexCoord3bvOES';
private static procedure z_MultiTexCoord3bvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord3bvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord3bvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; var coords: SByte) :=
z_MultiTexCoord3bvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord3bvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord3bvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord4bOES_ovr_0(texture: TextureUnit; s: SByte; t: SByte; r: SByte; q: SByte);
external 'opengl32.dll' name 'glMultiTexCoord4bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bOES(texture: TextureUnit; s: SByte; t: SByte; r: SByte; q: SByte) :=
z_MultiTexCoord4bOES_ovr_0(texture, s, t, r, q);
private static procedure z_MultiTexCoord4bvOES_ovr_0(texture: TextureUnit; var coords: SByte);
external 'opengl32.dll' name 'glMultiTexCoord4bvOES';
private static procedure z_MultiTexCoord4bvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord4bvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord4bvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; var coords: SByte) :=
z_MultiTexCoord4bvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord4bvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord4bvOES_ovr_2(texture, coords);
private static procedure z_TexCoord1bOES_ovr_0(s: SByte);
external 'opengl32.dll' name 'glTexCoord1bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bOES(s: SByte) :=
z_TexCoord1bOES_ovr_0(s);
private static procedure z_TexCoord1bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glTexCoord1bvOES';
private static procedure z_TexCoord1bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord1bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord1bvOES_ovr_0(coords[0]) else
z_TexCoord1bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(var coords: SByte) :=
z_TexCoord1bvOES_ovr_0(coords);
private static procedure z_TexCoord1bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord1bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(coords: IntPtr) :=
z_TexCoord1bvOES_ovr_2(coords);
private static procedure z_TexCoord2bOES_ovr_0(s: SByte; t: SByte);
external 'opengl32.dll' name 'glTexCoord2bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bOES(s: SByte; t: SByte) :=
z_TexCoord2bOES_ovr_0(s, t);
private static procedure z_TexCoord2bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glTexCoord2bvOES';
private static procedure z_TexCoord2bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord2bvOES_ovr_0(coords[0]) else
z_TexCoord2bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(var coords: SByte) :=
z_TexCoord2bvOES_ovr_0(coords);
private static procedure z_TexCoord2bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(coords: IntPtr) :=
z_TexCoord2bvOES_ovr_2(coords);
private static procedure z_TexCoord3bOES_ovr_0(s: SByte; t: SByte; r: SByte);
external 'opengl32.dll' name 'glTexCoord3bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bOES(s: SByte; t: SByte; r: SByte) :=
z_TexCoord3bOES_ovr_0(s, t, r);
private static procedure z_TexCoord3bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glTexCoord3bvOES';
private static procedure z_TexCoord3bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord3bvOES_ovr_0(coords[0]) else
z_TexCoord3bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(var coords: SByte) :=
z_TexCoord3bvOES_ovr_0(coords);
private static procedure z_TexCoord3bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(coords: IntPtr) :=
z_TexCoord3bvOES_ovr_2(coords);
private static procedure z_TexCoord4bOES_ovr_0(s: SByte; t: SByte; r: SByte; q: SByte);
external 'opengl32.dll' name 'glTexCoord4bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bOES(s: SByte; t: SByte; r: SByte; q: SByte) :=
z_TexCoord4bOES_ovr_0(s, t, r, q);
private static procedure z_TexCoord4bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glTexCoord4bvOES';
private static procedure z_TexCoord4bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord4bvOES_ovr_0(coords[0]) else
z_TexCoord4bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(var coords: SByte) :=
z_TexCoord4bvOES_ovr_0(coords);
private static procedure z_TexCoord4bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(coords: IntPtr) :=
z_TexCoord4bvOES_ovr_2(coords);
private static procedure z_Vertex2bOES_ovr_0(x: SByte; y: SByte);
external 'opengl32.dll' name 'glVertex2bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bOES(x: SByte; y: SByte) :=
z_Vertex2bOES_ovr_0(x, y);
private static procedure z_Vertex2bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glVertex2bvOES';
private static procedure z_Vertex2bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex2bvOES_ovr_0(coords[0]) else
z_Vertex2bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(var coords: SByte) :=
z_Vertex2bvOES_ovr_0(coords);
private static procedure z_Vertex2bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex2bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(coords: IntPtr) :=
z_Vertex2bvOES_ovr_2(coords);
private static procedure z_Vertex3bOES_ovr_0(x: SByte; y: SByte; z: SByte);
external 'opengl32.dll' name 'glVertex3bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bOES(x: SByte; y: SByte; z: SByte) :=
z_Vertex3bOES_ovr_0(x, y, z);
private static procedure z_Vertex3bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glVertex3bvOES';
private static procedure z_Vertex3bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex3bvOES_ovr_0(coords[0]) else
z_Vertex3bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(var coords: SByte) :=
z_Vertex3bvOES_ovr_0(coords);
private static procedure z_Vertex3bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex3bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(coords: IntPtr) :=
z_Vertex3bvOES_ovr_2(coords);
private static procedure z_Vertex4bOES_ovr_0(x: SByte; y: SByte; z: SByte; w: SByte);
external 'opengl32.dll' name 'glVertex4bOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bOES(x: SByte; y: SByte; z: SByte; w: SByte) :=
z_Vertex4bOES_ovr_0(x, y, z, w);
private static procedure z_Vertex4bvOES_ovr_0(var coords: SByte);
external 'opengl32.dll' name 'glVertex4bvOES';
private static procedure z_Vertex4bvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(coords: array of SByte) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex4bvOES_ovr_0(coords[0]) else
z_Vertex4bvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(var coords: SByte) :=
z_Vertex4bvOES_ovr_0(coords);
private static procedure z_Vertex4bvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex4bvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(coords: IntPtr) :=
z_Vertex4bvOES_ovr_2(coords);
end;
[PCUNotRestore]
glFixedPointOES = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_AlphaFuncxOES_ovr_0(func: AlphaFunction; ref: Fixed);
external 'opengl32.dll' name 'glAlphaFuncxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFuncxOES(func: AlphaFunction; ref: Fixed) :=
z_AlphaFuncxOES_ovr_0(func, ref);
private static procedure z_ClearColorxOES_ovr_0(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
external 'opengl32.dll' name 'glClearColorxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed) :=
z_ClearColorxOES_ovr_0(red, green, blue, alpha);
private static procedure z_ClearDepthxOES_ovr_0(depth: Fixed);
external 'opengl32.dll' name 'glClearDepthxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthxOES(depth: Fixed) :=
z_ClearDepthxOES_ovr_0(depth);
private static procedure z_ClipPlanexOES_ovr_0(plane: ClipPlaneName; var equation: Fixed);
external 'opengl32.dll' name 'glClipPlanexOES';
private static procedure z_ClipPlanexOES_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlanexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; equation: array of Fixed) :=
if (equation<>nil) and (equation.Length<>0) then
z_ClipPlanexOES_ovr_0(plane, equation[0]) else
z_ClipPlanexOES_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; var equation: Fixed) :=
z_ClipPlanexOES_ovr_0(plane, equation);
private static procedure z_ClipPlanexOES_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlanexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; equation: IntPtr) :=
z_ClipPlanexOES_ovr_2(plane, equation);
private static procedure z_Color4xOES_ovr_0(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
external 'opengl32.dll' name 'glColor4xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed) :=
z_Color4xOES_ovr_0(red, green, blue, alpha);
private static procedure z_DepthRangexOES_ovr_0(n: Fixed; f: Fixed);
external 'opengl32.dll' name 'glDepthRangexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangexOES(n: Fixed; f: Fixed) :=
z_DepthRangexOES_ovr_0(n, f);
private static procedure z_FogxOES_ovr_0(pname: FogPName; param: Fixed);
external 'opengl32.dll' name 'glFogxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxOES(pname: FogPName; param: Fixed) :=
z_FogxOES_ovr_0(pname, param);
private static procedure z_FogxvOES_ovr_0(pname: FogPName; var param: Fixed);
external 'opengl32.dll' name 'glFogxvOES';
private static procedure z_FogxvOES_ovr_0_anh001(pname: FogPName; param: IntPtr);
external 'opengl32.dll' name 'glFogxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; param: array of Fixed) :=
if (param<>nil) and (param.Length<>0) then
z_FogxvOES_ovr_0(pname, param[0]) else
z_FogxvOES_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; var param: Fixed) :=
z_FogxvOES_ovr_0(pname, param);
private static procedure z_FogxvOES_ovr_2(pname: FogPName; param: IntPtr);
external 'opengl32.dll' name 'glFogxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; param: IntPtr) :=
z_FogxvOES_ovr_2(pname, param);
private static procedure z_FrustumxOES_ovr_0(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed);
external 'opengl32.dll' name 'glFrustumxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrustumxOES(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed) :=
z_FrustumxOES_ovr_0(l, r, b, t, n, f);
private static procedure z_GetClipPlanexOES_ovr_0(plane: ClipPlaneName; var equation: Fixed);
external 'opengl32.dll' name 'glGetClipPlanexOES';
private static procedure z_GetClipPlanexOES_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlanexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; equation: array of Fixed) :=
if (equation<>nil) and (equation.Length<>0) then
z_GetClipPlanexOES_ovr_0(plane, equation[0]) else
z_GetClipPlanexOES_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; var equation: Fixed) :=
z_GetClipPlanexOES_ovr_0(plane, equation);
private static procedure z_GetClipPlanexOES_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlanexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; equation: IntPtr) :=
z_GetClipPlanexOES_ovr_2(plane, equation);
private static procedure z_GetFixedvOES_ovr_0(pname: GetPName; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetFixedvOES';
private static procedure z_GetFixedvOES_ovr_0_anh001(pname: GetPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFixedvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFixedvOES_ovr_0(pname, ¶ms[0]) else
z_GetFixedvOES_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; var ¶ms: Fixed) :=
z_GetFixedvOES_ovr_0(pname, ¶ms);
private static procedure z_GetFixedvOES_ovr_2(pname: GetPName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFixedvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; ¶ms: IntPtr) :=
z_GetFixedvOES_ovr_2(pname, ¶ms);
private static procedure z_GetTexEnvxvOES_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetTexEnvxvOES';
private static procedure z_GetTexEnvxvOES_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnvxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexEnvxvOES_ovr_0(target, pname, ¶ms[0]) else
z_GetTexEnvxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed) :=
z_GetTexEnvxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexEnvxvOES_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnvxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_GetTexEnvxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_GetTexParameterxvOES_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetTexParameterxvOES';
private static procedure z_GetTexParameterxvOES_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexParameterxvOES_ovr_0(target, pname, ¶ms[0]) else
z_GetTexParameterxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed) :=
z_GetTexParameterxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_GetTexParameterxvOES_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexParameterxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_LightModelxOES_ovr_0(pname: LightModelParameter; param: Fixed);
external 'opengl32.dll' name 'glLightModelxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxOES(pname: LightModelParameter; param: Fixed) :=
z_LightModelxOES_ovr_0(pname, param);
private static procedure z_LightModelxvOES_ovr_0(pname: LightModelParameter; var param: Fixed);
external 'opengl32.dll' name 'glLightModelxvOES';
private static procedure z_LightModelxvOES_ovr_0_anh001(pname: LightModelParameter; param: IntPtr);
external 'opengl32.dll' name 'glLightModelxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; param: array of Fixed) :=
if (param<>nil) and (param.Length<>0) then
z_LightModelxvOES_ovr_0(pname, param[0]) else
z_LightModelxvOES_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; var param: Fixed) :=
z_LightModelxvOES_ovr_0(pname, param);
private static procedure z_LightModelxvOES_ovr_2(pname: LightModelParameter; param: IntPtr);
external 'opengl32.dll' name 'glLightModelxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; param: IntPtr) :=
z_LightModelxvOES_ovr_2(pname, param);
private static procedure z_LightxOES_ovr_0(light: LightName; pname: LightParameter; param: Fixed);
external 'opengl32.dll' name 'glLightxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxOES(light: LightName; pname: LightParameter; param: Fixed) :=
z_LightxOES_ovr_0(light, pname, param);
private static procedure z_LightxvOES_ovr_0(light: LightName; pname: LightParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glLightxvOES';
private static procedure z_LightxvOES_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_LightxvOES_ovr_0(light, pname, ¶ms[0]) else
z_LightxvOES_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; var ¶ms: Fixed) :=
z_LightxvOES_ovr_0(light, pname, ¶ms);
private static procedure z_LightxvOES_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_LightxvOES_ovr_2(light, pname, ¶ms);
private static procedure z_LineWidthxOES_ovr_0(width: Fixed);
external 'opengl32.dll' name 'glLineWidthxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineWidthxOES(width: Fixed) :=
z_LineWidthxOES_ovr_0(width);
private static procedure z_LoadMatrixxOES_ovr_0(var m: Fixed);
external 'opengl32.dll' name 'glLoadMatrixxOES';
private static procedure z_LoadMatrixxOES_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(m: array of Fixed) :=
if (m<>nil) and (m.Length<>0) then
z_LoadMatrixxOES_ovr_0(m[0]) else
z_LoadMatrixxOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(var m: Fixed) :=
z_LoadMatrixxOES_ovr_0(m);
private static procedure z_LoadMatrixxOES_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(m: IntPtr) :=
z_LoadMatrixxOES_ovr_2(m);
private static procedure z_MaterialxOES_ovr_0(face: MaterialFace; pname: MaterialParameter; param: Fixed);
external 'opengl32.dll' name 'glMaterialxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxOES(face: MaterialFace; pname: MaterialParameter; param: Fixed) :=
z_MaterialxOES_ovr_0(face, pname, param);
private static procedure z_MaterialxvOES_ovr_0(face: MaterialFace; pname: MaterialParameter; var param: Fixed);
external 'opengl32.dll' name 'glMaterialxvOES';
private static procedure z_MaterialxvOES_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; param: IntPtr);
external 'opengl32.dll' name 'glMaterialxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: MaterialFace; pname: MaterialParameter; param: array of Fixed) :=
if (param<>nil) and (param.Length<>0) then
z_MaterialxvOES_ovr_0(face, pname, param[0]) else
z_MaterialxvOES_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: MaterialFace; pname: MaterialParameter; var param: Fixed) :=
z_MaterialxvOES_ovr_0(face, pname, param);
private static procedure z_MaterialxvOES_ovr_2(face: MaterialFace; pname: MaterialParameter; param: IntPtr);
external 'opengl32.dll' name 'glMaterialxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: MaterialFace; pname: MaterialParameter; param: IntPtr) :=
z_MaterialxvOES_ovr_2(face, pname, param);
private static procedure z_MultMatrixxOES_ovr_0(var m: Fixed);
external 'opengl32.dll' name 'glMultMatrixxOES';
private static procedure z_MultMatrixxOES_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(m: array of Fixed) :=
if (m<>nil) and (m.Length<>0) then
z_MultMatrixxOES_ovr_0(m[0]) else
z_MultMatrixxOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(var m: Fixed) :=
z_MultMatrixxOES_ovr_0(m);
private static procedure z_MultMatrixxOES_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(m: IntPtr) :=
z_MultMatrixxOES_ovr_2(m);
private static procedure z_MultiTexCoord4xOES_ovr_0(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed; q: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord4xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xOES(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed; q: Fixed) :=
z_MultiTexCoord4xOES_ovr_0(texture, s, t, r, q);
private static procedure z_Normal3xOES_ovr_0(nx: Fixed; ny: Fixed; nz: Fixed);
external 'opengl32.dll' name 'glNormal3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xOES(nx: Fixed; ny: Fixed; nz: Fixed) :=
z_Normal3xOES_ovr_0(nx, ny, nz);
private static procedure z_OrthoxOES_ovr_0(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed);
external 'opengl32.dll' name 'glOrthoxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure OrthoxOES(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed) :=
z_OrthoxOES_ovr_0(l, r, b, t, n, f);
private static procedure z_PointParameterxvOES_ovr_0(pname: PointParameterNameARB; var ¶ms: Fixed);
external 'opengl32.dll' name 'glPointParameterxvOES';
private static procedure z_PointParameterxvOES_ovr_0_anh001(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterxvOES_ovr_0(pname, ¶ms[0]) else
z_PointParameterxvOES_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; var ¶ms: Fixed) :=
z_PointParameterxvOES_ovr_0(pname, ¶ms);
private static procedure z_PointParameterxvOES_ovr_2(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterxvOES_ovr_2(pname, ¶ms);
private static procedure z_PointSizexOES_ovr_0(size: Fixed);
external 'opengl32.dll' name 'glPointSizexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointSizexOES(size: Fixed) :=
z_PointSizexOES_ovr_0(size);
private static procedure z_PolygonOffsetxOES_ovr_0(factor: Fixed; units: Fixed);
external 'opengl32.dll' name 'glPolygonOffsetxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetxOES(factor: Fixed; units: Fixed) :=
z_PolygonOffsetxOES_ovr_0(factor, units);
private static procedure z_RotatexOES_ovr_0(angle: Fixed; x: Fixed; y: Fixed; z: Fixed);
external 'opengl32.dll' name 'glRotatexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RotatexOES(angle: Fixed; x: Fixed; y: Fixed; z: Fixed) :=
z_RotatexOES_ovr_0(angle, x, y, z);
private static procedure z_ScalexOES_ovr_0(x: Fixed; y: Fixed; z: Fixed);
external 'opengl32.dll' name 'glScalexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScalexOES(x: Fixed; y: Fixed; z: Fixed) :=
z_ScalexOES_ovr_0(x, y, z);
private static procedure z_TexEnvxOES_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; param: Fixed);
external 'opengl32.dll' name 'glTexEnvxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxOES(target: TextureEnvTarget; pname: TextureEnvParameter; param: Fixed) :=
z_TexEnvxOES_ovr_0(target, pname, param);
private static procedure z_TexEnvxvOES_ovr_0(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glTexEnvxvOES';
private static procedure z_TexEnvxvOES_ovr_0_anh0001(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnvxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexEnvxvOES_ovr_0(target, pname, ¶ms[0]) else
z_TexEnvxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed) :=
z_TexEnvxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_TexEnvxvOES_ovr_2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnvxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) :=
z_TexEnvxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_TexParameterxOES_ovr_0(target: TextureTarget; pname: GetTextureParameter; param: Fixed);
external 'opengl32.dll' name 'glTexParameterxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxOES(target: TextureTarget; pname: GetTextureParameter; param: Fixed) :=
z_TexParameterxOES_ovr_0(target, pname, param);
private static procedure z_TexParameterxvOES_ovr_0(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glTexParameterxvOES';
private static procedure z_TexParameterxvOES_ovr_0_anh0001(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexParameterxvOES_ovr_0(target, pname, ¶ms[0]) else
z_TexParameterxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed) :=
z_TexParameterxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_TexParameterxvOES_ovr_2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_TexParameterxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_TranslatexOES_ovr_0(x: Fixed; y: Fixed; z: Fixed);
external 'opengl32.dll' name 'glTranslatexOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TranslatexOES(x: Fixed; y: Fixed; z: Fixed) :=
z_TranslatexOES_ovr_0(x, y, z);
private static procedure z_AccumxOES_ovr_0(op: DummyEnum; value: Fixed);
external 'opengl32.dll' name 'glAccumxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AccumxOES(op: DummyEnum; value: Fixed) :=
z_AccumxOES_ovr_0(op, value);
private static procedure z_BitmapxOES_ovr_0(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; var bitmap: Byte);
external 'opengl32.dll' name 'glBitmapxOES';
private static procedure z_BitmapxOES_ovr_0_anh00000001(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: IntPtr);
external 'opengl32.dll' name 'glBitmapxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: array of Byte) :=
if (bitmap<>nil) and (bitmap.Length<>0) then
z_BitmapxOES_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap[0]) else
z_BitmapxOES_ovr_0_anh00000001(width, height, xorig, yorig, xmove, ymove, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; var bitmap: Byte) :=
z_BitmapxOES_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap);
private static procedure z_BitmapxOES_ovr_2(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: IntPtr);
external 'opengl32.dll' name 'glBitmapxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: IntPtr) :=
z_BitmapxOES_ovr_2(width, height, xorig, yorig, xmove, ymove, bitmap);
private static procedure z_BlendColorxOES_ovr_0(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
external 'opengl32.dll' name 'glBlendColorxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColorxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed) :=
z_BlendColorxOES_ovr_0(red, green, blue, alpha);
private static procedure z_ClearAccumxOES_ovr_0(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
external 'opengl32.dll' name 'glClearAccumxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearAccumxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed) :=
z_ClearAccumxOES_ovr_0(red, green, blue, alpha);
private static procedure z_Color3xOES_ovr_0(red: Fixed; green: Fixed; blue: Fixed);
external 'opengl32.dll' name 'glColor3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xOES(red: Fixed; green: Fixed; blue: Fixed) :=
z_Color3xOES_ovr_0(red, green, blue);
private static procedure z_Color3xvOES_ovr_0(var components: Fixed);
external 'opengl32.dll' name 'glColor3xvOES';
private static procedure z_Color3xvOES_ovr_0_anh01(components: IntPtr);
external 'opengl32.dll' name 'glColor3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(components: array of Fixed) :=
if (components<>nil) and (components.Length<>0) then
z_Color3xvOES_ovr_0(components[0]) else
z_Color3xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(var components: Fixed) :=
z_Color3xvOES_ovr_0(components);
private static procedure z_Color3xvOES_ovr_2(components: IntPtr);
external 'opengl32.dll' name 'glColor3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(components: IntPtr) :=
z_Color3xvOES_ovr_2(components);
private static procedure z_Color4xvOES_ovr_0(var components: Fixed);
external 'opengl32.dll' name 'glColor4xvOES';
private static procedure z_Color4xvOES_ovr_0_anh01(components: IntPtr);
external 'opengl32.dll' name 'glColor4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(components: array of Fixed) :=
if (components<>nil) and (components.Length<>0) then
z_Color4xvOES_ovr_0(components[0]) else
z_Color4xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(var components: Fixed) :=
z_Color4xvOES_ovr_0(components);
private static procedure z_Color4xvOES_ovr_2(components: IntPtr);
external 'opengl32.dll' name 'glColor4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(components: IntPtr) :=
z_Color4xvOES_ovr_2(components);
private static procedure z_ConvolutionParameterxOES_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; param: Fixed);
external 'opengl32.dll' name 'glConvolutionParameterxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; param: Fixed) :=
z_ConvolutionParameterxOES_ovr_0(target, pname, param);
private static procedure z_ConvolutionParameterxvOES_ovr_0(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Fixed);
external 'opengl32.dll' name 'glConvolutionParameterxvOES';
private static procedure z_ConvolutionParameterxvOES_ovr_0_anh0001(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ConvolutionParameterxvOES_ovr_0(target, pname, ¶ms[0]) else
z_ConvolutionParameterxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Fixed) :=
z_ConvolutionParameterxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_ConvolutionParameterxvOES_ovr_2(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glConvolutionParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr) :=
z_ConvolutionParameterxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_EvalCoord1xOES_ovr_0(u: Fixed);
external 'opengl32.dll' name 'glEvalCoord1xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xOES(u: Fixed) :=
z_EvalCoord1xOES_ovr_0(u);
private static procedure z_EvalCoord1xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glEvalCoord1xvOES';
private static procedure z_EvalCoord1xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_EvalCoord1xvOES_ovr_0(coords[0]) else
z_EvalCoord1xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(var coords: Fixed) :=
z_EvalCoord1xvOES_ovr_0(coords);
private static procedure z_EvalCoord1xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(coords: IntPtr) :=
z_EvalCoord1xvOES_ovr_2(coords);
private static procedure z_EvalCoord2xOES_ovr_0(u: Fixed; v: Fixed);
external 'opengl32.dll' name 'glEvalCoord2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xOES(u: Fixed; v: Fixed) :=
z_EvalCoord2xOES_ovr_0(u, v);
private static procedure z_EvalCoord2xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glEvalCoord2xvOES';
private static procedure z_EvalCoord2xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_EvalCoord2xvOES_ovr_0(coords[0]) else
z_EvalCoord2xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(var coords: Fixed) :=
z_EvalCoord2xvOES_ovr_0(coords);
private static procedure z_EvalCoord2xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(coords: IntPtr) :=
z_EvalCoord2xvOES_ovr_2(coords);
private static procedure z_FeedbackBufferxOES_ovr_0(n: Int32; &type: DummyEnum; var buffer: Fixed);
external 'opengl32.dll' name 'glFeedbackBufferxOES';
private static procedure z_FeedbackBufferxOES_ovr_0_anh0001(n: Int32; &type: DummyEnum; buffer: IntPtr);
external 'opengl32.dll' name 'glFeedbackBufferxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; buffer: array of Fixed) :=
if (buffer<>nil) and (buffer.Length<>0) then
z_FeedbackBufferxOES_ovr_0(n, &type, buffer[0]) else
z_FeedbackBufferxOES_ovr_0_anh0001(n, &type, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; var buffer: Fixed) :=
z_FeedbackBufferxOES_ovr_0(n, &type, buffer);
private static procedure z_FeedbackBufferxOES_ovr_2(n: Int32; &type: DummyEnum; buffer: IntPtr);
external 'opengl32.dll' name 'glFeedbackBufferxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; buffer: IntPtr) :=
z_FeedbackBufferxOES_ovr_2(n, &type, buffer);
private static procedure z_GetConvolutionParameterxvOES_ovr_0(target: DummyEnum; pname: DummyEnum; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetConvolutionParameterxvOES';
private static procedure z_GetConvolutionParameterxvOES_ovr_0_anh0001(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetConvolutionParameterxvOES_ovr_0(target, pname, ¶ms[0]) else
z_GetConvolutionParameterxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; var ¶ms: Fixed) :=
z_GetConvolutionParameterxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_GetConvolutionParameterxvOES_ovr_2(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetConvolutionParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr) :=
z_GetConvolutionParameterxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_GetHistogramParameterxvOES_ovr_0(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetHistogramParameterxvOES';
private static procedure z_GetHistogramParameterxvOES_ovr_0_anh0001(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetHistogramParameterxvOES_ovr_0(target, pname, ¶ms[0]) else
z_GetHistogramParameterxvOES_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Fixed) :=
z_GetHistogramParameterxvOES_ovr_0(target, pname, ¶ms);
private static procedure z_GetHistogramParameterxvOES_ovr_2(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetHistogramParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr) :=
z_GetHistogramParameterxvOES_ovr_2(target, pname, ¶ms);
private static procedure z_GetLightxOES_ovr_0(light: LightName; pname: LightParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetLightxOES';
private static procedure z_GetLightxOES_ovr_0_anh0001(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetLightxOES_ovr_0(light, pname, ¶ms[0]) else
z_GetLightxOES_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; var ¶ms: Fixed) :=
z_GetLightxOES_ovr_0(light, pname, ¶ms);
private static procedure z_GetLightxOES_ovr_2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; ¶ms: IntPtr) :=
z_GetLightxOES_ovr_2(light, pname, ¶ms);
private static procedure z_GetMapxvOES_ovr_0(target: MapTarget; query: GetMapQuery; var v: Fixed);
external 'opengl32.dll' name 'glGetMapxvOES';
private static procedure z_GetMapxvOES_ovr_0_anh0001(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; v: array of Fixed) :=
if (v<>nil) and (v.Length<>0) then
z_GetMapxvOES_ovr_0(target, query, v[0]) else
z_GetMapxvOES_ovr_0_anh0001(target, query, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; var v: Fixed) :=
z_GetMapxvOES_ovr_0(target, query, v);
private static procedure z_GetMapxvOES_ovr_2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; v: IntPtr) :=
z_GetMapxvOES_ovr_2(target, query, v);
private static procedure z_GetMaterialxOES_ovr_0(face: MaterialFace; pname: MaterialParameter; param: Fixed);
external 'opengl32.dll' name 'glGetMaterialxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialxOES(face: MaterialFace; pname: MaterialParameter; param: Fixed) :=
z_GetMaterialxOES_ovr_0(face, pname, param);
private static procedure z_GetPixelMapxv_ovr_0(map: PixelMap; size: Int32; var values: Fixed);
external 'opengl32.dll' name 'glGetPixelMapxv';
private static procedure z_GetPixelMapxv_ovr_0_anh0001(map: PixelMap; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapxv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapxv(map: PixelMap; size: Int32; values: array of Fixed) :=
if (values<>nil) and (values.Length<>0) then
z_GetPixelMapxv_ovr_0(map, size, values[0]) else
z_GetPixelMapxv_ovr_0_anh0001(map, size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapxv(map: PixelMap; size: Int32; var values: Fixed) :=
z_GetPixelMapxv_ovr_0(map, size, values);
private static procedure z_GetPixelMapxv_ovr_2(map: PixelMap; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapxv';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapxv(map: PixelMap; size: Int32; values: IntPtr) :=
z_GetPixelMapxv_ovr_2(map, size, values);
private static procedure z_GetTexGenxvOES_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetTexGenxvOES';
private static procedure z_GetTexGenxvOES_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGenxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexGenxvOES_ovr_0(coord, pname, ¶ms[0]) else
z_GetTexGenxvOES_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed) :=
z_GetTexGenxvOES_ovr_0(coord, pname, ¶ms);
private static procedure z_GetTexGenxvOES_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGenxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_GetTexGenxvOES_ovr_2(coord, pname, ¶ms);
private static procedure z_GetTexLevelParameterxvOES_ovr_0(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glGetTexLevelParameterxvOES';
private static procedure z_GetTexLevelParameterxvOES_ovr_0_anh00001(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetTexLevelParameterxvOES_ovr_0(target, level, pname, ¶ms[0]) else
z_GetTexLevelParameterxvOES_ovr_0_anh00001(target, level, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Fixed) :=
z_GetTexLevelParameterxvOES_ovr_0(target, level, pname, ¶ms);
private static procedure z_GetTexLevelParameterxvOES_ovr_2(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameterxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) :=
z_GetTexLevelParameterxvOES_ovr_2(target, level, pname, ¶ms);
private static procedure z_IndexxOES_ovr_0(component: Fixed);
external 'opengl32.dll' name 'glIndexxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxOES(component: Fixed) :=
z_IndexxOES_ovr_0(component);
private static procedure z_IndexxvOES_ovr_0(var component: Fixed);
external 'opengl32.dll' name 'glIndexxvOES';
private static procedure z_IndexxvOES_ovr_0_anh01(component: IntPtr);
external 'opengl32.dll' name 'glIndexxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(component: array of Fixed) :=
if (component<>nil) and (component.Length<>0) then
z_IndexxvOES_ovr_0(component[0]) else
z_IndexxvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(var component: Fixed) :=
z_IndexxvOES_ovr_0(component);
private static procedure z_IndexxvOES_ovr_2(component: IntPtr);
external 'opengl32.dll' name 'glIndexxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(component: IntPtr) :=
z_IndexxvOES_ovr_2(component);
private static procedure z_LoadTransposeMatrixxOES_ovr_0(var m: Fixed);
external 'opengl32.dll' name 'glLoadTransposeMatrixxOES';
private static procedure z_LoadTransposeMatrixxOES_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(m: array of Fixed) :=
if (m<>nil) and (m.Length<>0) then
z_LoadTransposeMatrixxOES_ovr_0(m[0]) else
z_LoadTransposeMatrixxOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(var m: Fixed) :=
z_LoadTransposeMatrixxOES_ovr_0(m);
private static procedure z_LoadTransposeMatrixxOES_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glLoadTransposeMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(m: IntPtr) :=
z_LoadTransposeMatrixxOES_ovr_2(m);
private static procedure z_Map1xOES_ovr_0(target: MapTarget; u1: Fixed; u2: Fixed; stride: Int32; order: Int32; points: Fixed);
external 'opengl32.dll' name 'glMap1xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1xOES(target: MapTarget; u1: Fixed; u2: Fixed; stride: Int32; order: Int32; points: Fixed) :=
z_Map1xOES_ovr_0(target, u1, u2, stride, order, points);
private static procedure z_Map2xOES_ovr_0(target: MapTarget; u1: Fixed; u2: Fixed; ustride: Int32; uorder: Int32; v1: Fixed; v2: Fixed; vstride: Int32; vorder: Int32; points: Fixed);
external 'opengl32.dll' name 'glMap2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map2xOES(target: MapTarget; u1: Fixed; u2: Fixed; ustride: Int32; uorder: Int32; v1: Fixed; v2: Fixed; vstride: Int32; vorder: Int32; points: Fixed) :=
z_Map2xOES_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure z_MapGrid1xOES_ovr_0(n: Int32; u1: Fixed; u2: Fixed);
external 'opengl32.dll' name 'glMapGrid1xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1xOES(n: Int32; u1: Fixed; u2: Fixed) :=
z_MapGrid1xOES_ovr_0(n, u1, u2);
private static procedure z_MapGrid2xOES_ovr_0(n: Int32; u1: Fixed; u2: Fixed; v1: Fixed; v2: Fixed);
external 'opengl32.dll' name 'glMapGrid2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2xOES(n: Int32; u1: Fixed; u2: Fixed; v1: Fixed; v2: Fixed) :=
z_MapGrid2xOES_ovr_0(n, u1, u2, v1, v2);
private static procedure z_MultTransposeMatrixxOES_ovr_0(var m: Fixed);
external 'opengl32.dll' name 'glMultTransposeMatrixxOES';
private static procedure z_MultTransposeMatrixxOES_ovr_0_anh01(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(m: array of Fixed) :=
if (m<>nil) and (m.Length<>0) then
z_MultTransposeMatrixxOES_ovr_0(m[0]) else
z_MultTransposeMatrixxOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(var m: Fixed) :=
z_MultTransposeMatrixxOES_ovr_0(m);
private static procedure z_MultTransposeMatrixxOES_ovr_2(m: IntPtr);
external 'opengl32.dll' name 'glMultTransposeMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(m: IntPtr) :=
z_MultTransposeMatrixxOES_ovr_2(m);
private static procedure z_MultiTexCoord1xOES_ovr_0(texture: TextureUnit; s: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord1xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xOES(texture: TextureUnit; s: Fixed) :=
z_MultiTexCoord1xOES_ovr_0(texture, s);
private static procedure z_MultiTexCoord1xvOES_ovr_0(texture: TextureUnit; var coords: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord1xvOES';
private static procedure z_MultiTexCoord1xvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord1xvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord1xvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; var coords: Fixed) :=
z_MultiTexCoord1xvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord1xvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord1xvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord2xOES_ovr_0(texture: TextureUnit; s: Fixed; t: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xOES(texture: TextureUnit; s: Fixed; t: Fixed) :=
z_MultiTexCoord2xOES_ovr_0(texture, s, t);
private static procedure z_MultiTexCoord2xvOES_ovr_0(texture: TextureUnit; var coords: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord2xvOES';
private static procedure z_MultiTexCoord2xvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord2xvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord2xvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; var coords: Fixed) :=
z_MultiTexCoord2xvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord2xvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord2xvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord3xOES_ovr_0(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xOES(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed) :=
z_MultiTexCoord3xOES_ovr_0(texture, s, t, r);
private static procedure z_MultiTexCoord3xvOES_ovr_0(texture: TextureUnit; var coords: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord3xvOES';
private static procedure z_MultiTexCoord3xvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord3xvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord3xvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; var coords: Fixed) :=
z_MultiTexCoord3xvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord3xvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord3xvOES_ovr_2(texture, coords);
private static procedure z_MultiTexCoord4xvOES_ovr_0(texture: TextureUnit; var coords: Fixed);
external 'opengl32.dll' name 'glMultiTexCoord4xvOES';
private static procedure z_MultiTexCoord4xvOES_ovr_0_anh001(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_MultiTexCoord4xvOES_ovr_0(texture, coords[0]) else
z_MultiTexCoord4xvOES_ovr_0_anh001(texture, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; var coords: Fixed) :=
z_MultiTexCoord4xvOES_ovr_0(texture, coords);
private static procedure z_MultiTexCoord4xvOES_ovr_2(texture: TextureUnit; coords: IntPtr);
external 'opengl32.dll' name 'glMultiTexCoord4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; coords: IntPtr) :=
z_MultiTexCoord4xvOES_ovr_2(texture, coords);
private static procedure z_Normal3xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glNormal3xvOES';
private static procedure z_Normal3xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glNormal3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_Normal3xvOES_ovr_0(coords[0]) else
z_Normal3xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(var coords: Fixed) :=
z_Normal3xvOES_ovr_0(coords);
private static procedure z_Normal3xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glNormal3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(coords: IntPtr) :=
z_Normal3xvOES_ovr_2(coords);
private static procedure z_PassThroughxOES_ovr_0(token: Fixed);
external 'opengl32.dll' name 'glPassThroughxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassThroughxOES(token: Fixed) :=
z_PassThroughxOES_ovr_0(token);
private static procedure z_PixelMapx_ovr_0(map: PixelMap; size: Int32; var values: Fixed);
external 'opengl32.dll' name 'glPixelMapx';
private static procedure z_PixelMapx_ovr_0_anh0001(map: PixelMap; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapx';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapx(map: PixelMap; size: Int32; values: array of Fixed) :=
if (values<>nil) and (values.Length<>0) then
z_PixelMapx_ovr_0(map, size, values[0]) else
z_PixelMapx_ovr_0_anh0001(map, size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapx(map: PixelMap; size: Int32; var values: Fixed) :=
z_PixelMapx_ovr_0(map, size, values);
private static procedure z_PixelMapx_ovr_2(map: PixelMap; size: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapx';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapx(map: PixelMap; size: Int32; values: IntPtr) :=
z_PixelMapx_ovr_2(map, size, values);
private static procedure z_PixelStorex_ovr_0(pname: PixelStoreParameter; param: Fixed);
external 'opengl32.dll' name 'glPixelStorex';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelStorex(pname: PixelStoreParameter; param: Fixed) :=
z_PixelStorex_ovr_0(pname, param);
private static procedure z_PixelTransferxOES_ovr_0(pname: PixelTransferParameter; param: Fixed);
external 'opengl32.dll' name 'glPixelTransferxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferxOES(pname: PixelTransferParameter; param: Fixed) :=
z_PixelTransferxOES_ovr_0(pname, param);
private static procedure z_PixelZoomxOES_ovr_0(xfactor: Fixed; yfactor: Fixed);
external 'opengl32.dll' name 'glPixelZoomxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelZoomxOES(xfactor: Fixed; yfactor: Fixed) :=
z_PixelZoomxOES_ovr_0(xfactor, yfactor);
private static procedure z_PrioritizeTexturesxOES_ovr_0(n: Int32; var textures: UInt32; var priorities: Fixed);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
private static procedure z_PrioritizeTexturesxOES_ovr_0_anh0010(n: Int32; textures: IntPtr; var priorities: Fixed);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
private static procedure z_PrioritizeTexturesxOES_ovr_0_anh0001(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
private static procedure z_PrioritizeTexturesxOES_ovr_0_anh0011(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; priorities: array of Fixed) :=
if (textures<>nil) and (textures.Length<>0) then
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesxOES_ovr_0(n, textures[0], priorities[0]) else
z_PrioritizeTexturesxOES_ovr_0_anh0001(n, textures[0], IntPtr.Zero) else
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesxOES_ovr_0_anh0010(n, IntPtr.Zero, priorities[0]) else
z_PrioritizeTexturesxOES_ovr_0_anh0011(n, IntPtr.Zero, IntPtr.Zero);
private static procedure z_PrioritizeTexturesxOES_ovr_1_anh0010(n: Int32; textures: IntPtr; var priorities: Fixed);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; var priorities: Fixed) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTexturesxOES_ovr_0(n, textures[0], priorities) else
z_PrioritizeTexturesxOES_ovr_0_anh0010(n, IntPtr.Zero, priorities);
private static procedure z_PrioritizeTexturesxOES_ovr_2(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
private static procedure z_PrioritizeTexturesxOES_ovr_2_anh0010(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; priorities: IntPtr) :=
if (textures<>nil) and (textures.Length<>0) then
z_PrioritizeTexturesxOES_ovr_2(n, textures[0], priorities) else
z_PrioritizeTexturesxOES_ovr_2_anh0010(n, IntPtr.Zero, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; priorities: array of Fixed) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesxOES_ovr_0(n, textures, priorities[0]) else
z_PrioritizeTexturesxOES_ovr_0_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; var priorities: Fixed) :=
z_PrioritizeTexturesxOES_ovr_0(n, textures, priorities);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; priorities: IntPtr) :=
z_PrioritizeTexturesxOES_ovr_2(n, textures, priorities);
private static procedure z_PrioritizeTexturesxOES_ovr_6(n: Int32; textures: IntPtr; var priorities: Fixed);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
private static procedure z_PrioritizeTexturesxOES_ovr_6_anh0001(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; priorities: array of Fixed) :=
if (priorities<>nil) and (priorities.Length<>0) then
z_PrioritizeTexturesxOES_ovr_6(n, textures, priorities[0]) else
z_PrioritizeTexturesxOES_ovr_6_anh0001(n, textures, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; var priorities: Fixed) :=
z_PrioritizeTexturesxOES_ovr_6(n, textures, priorities);
private static procedure z_PrioritizeTexturesxOES_ovr_8(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTexturesxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; priorities: IntPtr) :=
z_PrioritizeTexturesxOES_ovr_8(n, textures, priorities);
private static procedure z_RasterPos2xOES_ovr_0(x: Fixed; y: Fixed);
external 'opengl32.dll' name 'glRasterPos2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xOES(x: Fixed; y: Fixed) :=
z_RasterPos2xOES_ovr_0(x, y);
private static procedure z_RasterPos2xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glRasterPos2xvOES';
private static procedure z_RasterPos2xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_RasterPos2xvOES_ovr_0(coords[0]) else
z_RasterPos2xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(var coords: Fixed) :=
z_RasterPos2xvOES_ovr_0(coords);
private static procedure z_RasterPos2xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(coords: IntPtr) :=
z_RasterPos2xvOES_ovr_2(coords);
private static procedure z_RasterPos3xOES_ovr_0(x: Fixed; y: Fixed; z: Fixed);
external 'opengl32.dll' name 'glRasterPos3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xOES(x: Fixed; y: Fixed; z: Fixed) :=
z_RasterPos3xOES_ovr_0(x, y, z);
private static procedure z_RasterPos3xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glRasterPos3xvOES';
private static procedure z_RasterPos3xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_RasterPos3xvOES_ovr_0(coords[0]) else
z_RasterPos3xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(var coords: Fixed) :=
z_RasterPos3xvOES_ovr_0(coords);
private static procedure z_RasterPos3xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(coords: IntPtr) :=
z_RasterPos3xvOES_ovr_2(coords);
private static procedure z_RasterPos4xOES_ovr_0(x: Fixed; y: Fixed; z: Fixed; w: Fixed);
external 'opengl32.dll' name 'glRasterPos4xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xOES(x: Fixed; y: Fixed; z: Fixed; w: Fixed) :=
z_RasterPos4xOES_ovr_0(x, y, z, w);
private static procedure z_RasterPos4xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glRasterPos4xvOES';
private static procedure z_RasterPos4xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_RasterPos4xvOES_ovr_0(coords[0]) else
z_RasterPos4xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(var coords: Fixed) :=
z_RasterPos4xvOES_ovr_0(coords);
private static procedure z_RasterPos4xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glRasterPos4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(coords: IntPtr) :=
z_RasterPos4xvOES_ovr_2(coords);
private static procedure z_RectxOES_ovr_0(x1: Fixed; y1: Fixed; x2: Fixed; y2: Fixed);
external 'opengl32.dll' name 'glRectxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxOES(x1: Fixed; y1: Fixed; x2: Fixed; y2: Fixed) :=
z_RectxOES_ovr_0(x1, y1, x2, y2);
private static procedure z_RectxvOES_ovr_0(var v1: Fixed; var v2: Fixed);
external 'opengl32.dll' name 'glRectxvOES';
private static procedure z_RectxvOES_ovr_0_anh010(v1: IntPtr; var v2: Fixed);
external 'opengl32.dll' name 'glRectxvOES';
private static procedure z_RectxvOES_ovr_0_anh001(var v1: Fixed; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
private static procedure z_RectxvOES_ovr_0_anh011(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; v2: array of Fixed) :=
if (v1<>nil) and (v1.Length<>0) then
if (v2<>nil) and (v2.Length<>0) then
z_RectxvOES_ovr_0(v1[0], v2[0]) else
z_RectxvOES_ovr_0_anh001(v1[0], IntPtr.Zero) else
if (v2<>nil) and (v2.Length<>0) then
z_RectxvOES_ovr_0_anh010(IntPtr.Zero, v2[0]) else
z_RectxvOES_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static procedure z_RectxvOES_ovr_1_anh010(v1: IntPtr; var v2: Fixed);
external 'opengl32.dll' name 'glRectxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; var v2: Fixed) :=
if (v1<>nil) and (v1.Length<>0) then
z_RectxvOES_ovr_0(v1[0], v2) else
z_RectxvOES_ovr_0_anh010(IntPtr.Zero, v2);
private static procedure z_RectxvOES_ovr_2(var v1: Fixed; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
private static procedure z_RectxvOES_ovr_2_anh010(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; v2: IntPtr) :=
if (v1<>nil) and (v1.Length<>0) then
z_RectxvOES_ovr_2(v1[0], v2) else
z_RectxvOES_ovr_2_anh010(IntPtr.Zero, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; v2: array of Fixed) :=
if (v2<>nil) and (v2.Length<>0) then
z_RectxvOES_ovr_0(v1, v2[0]) else
z_RectxvOES_ovr_0_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; var v2: Fixed) :=
z_RectxvOES_ovr_0(v1, v2);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; v2: IntPtr) :=
z_RectxvOES_ovr_2(v1, v2);
private static procedure z_RectxvOES_ovr_6(v1: IntPtr; var v2: Fixed);
external 'opengl32.dll' name 'glRectxvOES';
private static procedure z_RectxvOES_ovr_6_anh001(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; v2: array of Fixed) :=
if (v2<>nil) and (v2.Length<>0) then
z_RectxvOES_ovr_6(v1, v2[0]) else
z_RectxvOES_ovr_6_anh001(v1, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; var v2: Fixed) :=
z_RectxvOES_ovr_6(v1, v2);
private static procedure z_RectxvOES_ovr_8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; v2: IntPtr) :=
z_RectxvOES_ovr_8(v1, v2);
private static procedure z_TexCoord1xOES_ovr_0(s: Fixed);
external 'opengl32.dll' name 'glTexCoord1xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xOES(s: Fixed) :=
z_TexCoord1xOES_ovr_0(s);
private static procedure z_TexCoord1xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glTexCoord1xvOES';
private static procedure z_TexCoord1xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord1xvOES_ovr_0(coords[0]) else
z_TexCoord1xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(var coords: Fixed) :=
z_TexCoord1xvOES_ovr_0(coords);
private static procedure z_TexCoord1xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord1xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(coords: IntPtr) :=
z_TexCoord1xvOES_ovr_2(coords);
private static procedure z_TexCoord2xOES_ovr_0(s: Fixed; t: Fixed);
external 'opengl32.dll' name 'glTexCoord2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xOES(s: Fixed; t: Fixed) :=
z_TexCoord2xOES_ovr_0(s, t);
private static procedure z_TexCoord2xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glTexCoord2xvOES';
private static procedure z_TexCoord2xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord2xvOES_ovr_0(coords[0]) else
z_TexCoord2xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(var coords: Fixed) :=
z_TexCoord2xvOES_ovr_0(coords);
private static procedure z_TexCoord2xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(coords: IntPtr) :=
z_TexCoord2xvOES_ovr_2(coords);
private static procedure z_TexCoord3xOES_ovr_0(s: Fixed; t: Fixed; r: Fixed);
external 'opengl32.dll' name 'glTexCoord3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xOES(s: Fixed; t: Fixed; r: Fixed) :=
z_TexCoord3xOES_ovr_0(s, t, r);
private static procedure z_TexCoord3xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glTexCoord3xvOES';
private static procedure z_TexCoord3xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord3xvOES_ovr_0(coords[0]) else
z_TexCoord3xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(var coords: Fixed) :=
z_TexCoord3xvOES_ovr_0(coords);
private static procedure z_TexCoord3xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(coords: IntPtr) :=
z_TexCoord3xvOES_ovr_2(coords);
private static procedure z_TexCoord4xOES_ovr_0(s: Fixed; t: Fixed; r: Fixed; q: Fixed);
external 'opengl32.dll' name 'glTexCoord4xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xOES(s: Fixed; t: Fixed; r: Fixed; q: Fixed) :=
z_TexCoord4xOES_ovr_0(s, t, r, q);
private static procedure z_TexCoord4xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glTexCoord4xvOES';
private static procedure z_TexCoord4xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_TexCoord4xvOES_ovr_0(coords[0]) else
z_TexCoord4xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(var coords: Fixed) :=
z_TexCoord4xvOES_ovr_0(coords);
private static procedure z_TexCoord4xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glTexCoord4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(coords: IntPtr) :=
z_TexCoord4xvOES_ovr_2(coords);
private static procedure z_TexGenxOES_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; param: Fixed);
external 'opengl32.dll' name 'glTexGenxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxOES(coord: TextureCoordName; pname: TextureGenParameter; param: Fixed) :=
z_TexGenxOES_ovr_0(coord, pname, param);
private static procedure z_TexGenxvOES_ovr_0(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed);
external 'opengl32.dll' name 'glTexGenxvOES';
private static procedure z_TexGenxvOES_ovr_0_anh0001(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGenxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Fixed) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_TexGenxvOES_ovr_0(coord, pname, ¶ms[0]) else
z_TexGenxvOES_ovr_0_anh0001(coord, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed) :=
z_TexGenxvOES_ovr_0(coord, pname, ¶ms);
private static procedure z_TexGenxvOES_ovr_2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGenxvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) :=
z_TexGenxvOES_ovr_2(coord, pname, ¶ms);
private static procedure z_Vertex2xOES_ovr_0(x: Fixed);
external 'opengl32.dll' name 'glVertex2xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xOES(x: Fixed) :=
z_Vertex2xOES_ovr_0(x);
private static procedure z_Vertex2xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glVertex2xvOES';
private static procedure z_Vertex2xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex2xvOES_ovr_0(coords[0]) else
z_Vertex2xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(var coords: Fixed) :=
z_Vertex2xvOES_ovr_0(coords);
private static procedure z_Vertex2xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex2xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(coords: IntPtr) :=
z_Vertex2xvOES_ovr_2(coords);
private static procedure z_Vertex3xOES_ovr_0(x: Fixed; y: Fixed);
external 'opengl32.dll' name 'glVertex3xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xOES(x: Fixed; y: Fixed) :=
z_Vertex3xOES_ovr_0(x, y);
private static procedure z_Vertex3xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glVertex3xvOES';
private static procedure z_Vertex3xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex3xvOES_ovr_0(coords[0]) else
z_Vertex3xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(var coords: Fixed) :=
z_Vertex3xvOES_ovr_0(coords);
private static procedure z_Vertex3xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex3xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(coords: IntPtr) :=
z_Vertex3xvOES_ovr_2(coords);
private static procedure z_Vertex4xOES_ovr_0(x: Fixed; y: Fixed; z: Fixed);
external 'opengl32.dll' name 'glVertex4xOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xOES(x: Fixed; y: Fixed; z: Fixed) :=
z_Vertex4xOES_ovr_0(x, y, z);
private static procedure z_Vertex4xvOES_ovr_0(var coords: Fixed);
external 'opengl32.dll' name 'glVertex4xvOES';
private static procedure z_Vertex4xvOES_ovr_0_anh01(coords: IntPtr);
external 'opengl32.dll' name 'glVertex4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(coords: array of Fixed) :=
if (coords<>nil) and (coords.Length<>0) then
z_Vertex4xvOES_ovr_0(coords[0]) else
z_Vertex4xvOES_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(var coords: Fixed) :=
z_Vertex4xvOES_ovr_0(coords);
private static procedure z_Vertex4xvOES_ovr_2(coords: IntPtr);
external 'opengl32.dll' name 'glVertex4xvOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(coords: IntPtr) :=
z_Vertex4xvOES_ovr_2(coords);
end;
[PCUNotRestore]
glQueryMatrixOES = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_QueryMatrixxOES_ovr_0(var mantissa: Fixed; var exponent: Int32): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
private static function z_QueryMatrixxOES_ovr_0_anh010(mantissa: IntPtr; var exponent: Int32): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
private static function z_QueryMatrixxOES_ovr_0_anh001(var mantissa: Fixed; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
private static function z_QueryMatrixxOES_ovr_0_anh011(mantissa: IntPtr; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; exponent: array of Int32): DummyFlags :=
if (mantissa<>nil) and (mantissa.Length<>0) then
if (exponent<>nil) and (exponent.Length<>0) then
z_QueryMatrixxOES_ovr_0(mantissa[0], exponent[0]) else
z_QueryMatrixxOES_ovr_0_anh001(mantissa[0], IntPtr.Zero) else
if (exponent<>nil) and (exponent.Length<>0) then
z_QueryMatrixxOES_ovr_0_anh010(IntPtr.Zero, exponent[0]) else
z_QueryMatrixxOES_ovr_0_anh011(IntPtr.Zero, IntPtr.Zero);
private static function z_QueryMatrixxOES_ovr_1_anh010(mantissa: IntPtr; var exponent: Int32): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; var exponent: Int32): DummyFlags :=
if (mantissa<>nil) and (mantissa.Length<>0) then
z_QueryMatrixxOES_ovr_0(mantissa[0], exponent) else
z_QueryMatrixxOES_ovr_0_anh010(IntPtr.Zero, exponent);
private static function z_QueryMatrixxOES_ovr_2(var mantissa: Fixed; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
private static function z_QueryMatrixxOES_ovr_2_anh010(mantissa: IntPtr; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; exponent: IntPtr): DummyFlags :=
if (mantissa<>nil) and (mantissa.Length<>0) then
z_QueryMatrixxOES_ovr_2(mantissa[0], exponent) else
z_QueryMatrixxOES_ovr_2_anh010(IntPtr.Zero, exponent);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; exponent: array of Int32): DummyFlags :=
if (exponent<>nil) and (exponent.Length<>0) then
z_QueryMatrixxOES_ovr_0(mantissa, exponent[0]) else
z_QueryMatrixxOES_ovr_0_anh001(mantissa, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; var exponent: Int32): DummyFlags :=
z_QueryMatrixxOES_ovr_0(mantissa, exponent);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; exponent: IntPtr): DummyFlags :=
z_QueryMatrixxOES_ovr_2(mantissa, exponent);
private static function z_QueryMatrixxOES_ovr_6(mantissa: IntPtr; var exponent: Int32): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
private static function z_QueryMatrixxOES_ovr_6_anh001(mantissa: IntPtr; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; exponent: array of Int32): DummyFlags :=
if (exponent<>nil) and (exponent.Length<>0) then
z_QueryMatrixxOES_ovr_6(mantissa, exponent[0]) else
z_QueryMatrixxOES_ovr_6_anh001(mantissa, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; var exponent: Int32): DummyFlags :=
z_QueryMatrixxOES_ovr_6(mantissa, exponent);
private static function z_QueryMatrixxOES_ovr_8(mantissa: IntPtr; exponent: IntPtr): DummyFlags;
external 'opengl32.dll' name 'glQueryMatrixxOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; exponent: IntPtr): DummyFlags :=
z_QueryMatrixxOES_ovr_8(mantissa, exponent);
end;
[PCUNotRestore]
glSinglePrecisionOES = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ClearDepthfOES_ovr_0(depth: single);
external 'opengl32.dll' name 'glClearDepthfOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthfOES(depth: single) :=
z_ClearDepthfOES_ovr_0(depth);
private static procedure z_ClipPlanefOES_ovr_0(plane: ClipPlaneName; var equation: single);
external 'opengl32.dll' name 'glClipPlanefOES';
private static procedure z_ClipPlanefOES_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlanefOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; equation: array of single) :=
if (equation<>nil) and (equation.Length<>0) then
z_ClipPlanefOES_ovr_0(plane, equation[0]) else
z_ClipPlanefOES_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; var equation: single) :=
z_ClipPlanefOES_ovr_0(plane, equation);
private static procedure z_ClipPlanefOES_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlanefOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; equation: IntPtr) :=
z_ClipPlanefOES_ovr_2(plane, equation);
private static procedure z_DepthRangefOES_ovr_0(n: single; f: single);
external 'opengl32.dll' name 'glDepthRangefOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangefOES(n: single; f: single) :=
z_DepthRangefOES_ovr_0(n, f);
private static procedure z_FrustumfOES_ovr_0(l: single; r: single; b: single; t: single; n: single; f: single);
external 'opengl32.dll' name 'glFrustumfOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrustumfOES(l: single; r: single; b: single; t: single; n: single; f: single) :=
z_FrustumfOES_ovr_0(l, r, b, t, n, f);
private static procedure z_GetClipPlanefOES_ovr_0(plane: ClipPlaneName; var equation: single);
external 'opengl32.dll' name 'glGetClipPlanefOES';
private static procedure z_GetClipPlanefOES_ovr_0_anh001(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlanefOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; equation: array of single) :=
if (equation<>nil) and (equation.Length<>0) then
z_GetClipPlanefOES_ovr_0(plane, equation[0]) else
z_GetClipPlanefOES_ovr_0_anh001(plane, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; var equation: single) :=
z_GetClipPlanefOES_ovr_0(plane, equation);
private static procedure z_GetClipPlanefOES_ovr_2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlanefOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; equation: IntPtr) :=
z_GetClipPlanefOES_ovr_2(plane, equation);
private static procedure z_OrthofOES_ovr_0(l: single; r: single; b: single; t: single; n: single; f: single);
external 'opengl32.dll' name 'glOrthofOES';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure OrthofOES(l: single; r: single; b: single; t: single; n: single; f: single) :=
z_OrthofOES_ovr_0(l, r, b, t, n, f);
end;
[PCUNotRestore]
glMultiviewOVR = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FramebufferTextureMultiviewOVR_ovr_0(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; baseViewIndex: Int32; numViews: Int32);
external 'opengl32.dll' name 'glFramebufferTextureMultiviewOVR';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureMultiviewOVR(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; baseViewIndex: Int32; numViews: Int32) :=
z_FramebufferTextureMultiviewOVR_ovr_0(target, attachment, texture, level, baseViewIndex, numViews);
end;
[PCUNotRestore]
glMiscHintsPGI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_HintPGI_ovr_0(target: HintTargetPGI; mode: Int32);
external 'opengl32.dll' name 'glHintPGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure HintPGI(target: HintTargetPGI; mode: Int32) :=
z_HintPGI_ovr_0(target, mode);
end;
[PCUNotRestore]
glDetailTextureSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DetailTexFuncSGIS_ovr_0(target: TextureTarget; n: Int32; var points: single);
external 'opengl32.dll' name 'glDetailTexFuncSGIS';
private static procedure z_DetailTexFuncSGIS_ovr_0_anh0001(target: TextureTarget; n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDetailTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_DetailTexFuncSGIS_ovr_0(target, n, points[0]) else
z_DetailTexFuncSGIS_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; var points: single) :=
z_DetailTexFuncSGIS_ovr_0(target, n, points);
private static procedure z_DetailTexFuncSGIS_ovr_2(target: TextureTarget; n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDetailTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; points: IntPtr) :=
z_DetailTexFuncSGIS_ovr_2(target, n, points);
private static procedure z_GetDetailTexFuncSGIS_ovr_0(target: TextureTarget; var points: single);
external 'opengl32.dll' name 'glGetDetailTexFuncSGIS';
private static procedure z_GetDetailTexFuncSGIS_ovr_0_anh001(target: TextureTarget; points: IntPtr);
external 'opengl32.dll' name 'glGetDetailTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_GetDetailTexFuncSGIS_ovr_0(target, points[0]) else
z_GetDetailTexFuncSGIS_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; var points: single) :=
z_GetDetailTexFuncSGIS_ovr_0(target, points);
private static procedure z_GetDetailTexFuncSGIS_ovr_2(target: TextureTarget; points: IntPtr);
external 'opengl32.dll' name 'glGetDetailTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; points: IntPtr) :=
z_GetDetailTexFuncSGIS_ovr_2(target, points);
end;
[PCUNotRestore]
glFogFunctionSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FogFuncSGIS_ovr_0(n: Int32; var points: single);
external 'opengl32.dll' name 'glFogFuncSGIS';
private static procedure z_FogFuncSGIS_ovr_0_anh001(n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glFogFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_FogFuncSGIS_ovr_0(n, points[0]) else
z_FogFuncSGIS_ovr_0_anh001(n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; var points: single) :=
z_FogFuncSGIS_ovr_0(n, points);
private static procedure z_FogFuncSGIS_ovr_2(n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glFogFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; points: IntPtr) :=
z_FogFuncSGIS_ovr_2(n, points);
private static procedure z_GetFogFuncSGIS_ovr_0(var points: single);
external 'opengl32.dll' name 'glGetFogFuncSGIS';
private static procedure z_GetFogFuncSGIS_ovr_0_anh01(points: IntPtr);
external 'opengl32.dll' name 'glGetFogFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_GetFogFuncSGIS_ovr_0(points[0]) else
z_GetFogFuncSGIS_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(var points: single) :=
z_GetFogFuncSGIS_ovr_0(points);
private static procedure z_GetFogFuncSGIS_ovr_2(points: IntPtr);
external 'opengl32.dll' name 'glGetFogFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(points: IntPtr) :=
z_GetFogFuncSGIS_ovr_2(points);
end;
[PCUNotRestore]
glMultisampleSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SampleMaskSGIS_ovr_0(value: single; invert: boolean);
external 'opengl32.dll' name 'glSampleMaskSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskSGIS(value: single; invert: boolean) :=
z_SampleMaskSGIS_ovr_0(value, invert);
private static procedure z_SamplePatternSGIS_ovr_0(pattern: OpenGL.SamplePatternSGIS);
external 'opengl32.dll' name 'glSamplePatternSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplePatternSGIS(pattern: OpenGL.SamplePatternSGIS) :=
z_SamplePatternSGIS_ovr_0(pattern);
end;
[PCUNotRestore]
glPixelTextureSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PixelTexGenParameteriSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; param: Int32);
external 'opengl32.dll' name 'glPixelTexGenParameteriSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameteriSGIS(pname: PixelTexGenParameterNameSGIS; param: Int32) :=
z_PixelTexGenParameteriSGIS_ovr_0(pname, param);
private static procedure z_PixelTexGenParameterivSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32);
external 'opengl32.dll' name 'glPixelTexGenParameterivSGIS';
private static procedure z_PixelTexGenParameterivSGIS_ovr_0_anh001(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTexGenParameterivSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PixelTexGenParameterivSGIS_ovr_0(pname, ¶ms[0]) else
z_PixelTexGenParameterivSGIS_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32) :=
z_PixelTexGenParameterivSGIS_ovr_0(pname, ¶ms);
private static procedure z_PixelTexGenParameterivSGIS_ovr_2(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTexGenParameterivSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr) :=
z_PixelTexGenParameterivSGIS_ovr_2(pname, ¶ms);
private static procedure z_PixelTexGenParameterfSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; param: single);
external 'opengl32.dll' name 'glPixelTexGenParameterfSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfSGIS(pname: PixelTexGenParameterNameSGIS; param: single) :=
z_PixelTexGenParameterfSGIS_ovr_0(pname, param);
private static procedure z_PixelTexGenParameterfvSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; var ¶ms: single);
external 'opengl32.dll' name 'glPixelTexGenParameterfvSGIS';
private static procedure z_PixelTexGenParameterfvSGIS_ovr_0_anh001(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTexGenParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms[0]) else
z_PixelTexGenParameterfvSGIS_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: single) :=
z_PixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms);
private static procedure z_PixelTexGenParameterfvSGIS_ovr_2(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPixelTexGenParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr) :=
z_PixelTexGenParameterfvSGIS_ovr_2(pname, ¶ms);
private static procedure z_GetPixelTexGenParameterivSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetPixelTexGenParameterivSGIS';
private static procedure z_GetPixelTexGenParameterivSGIS_ovr_0_anh001(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTexGenParameterivSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPixelTexGenParameterivSGIS_ovr_0(pname, ¶ms[0]) else
z_GetPixelTexGenParameterivSGIS_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32) :=
z_GetPixelTexGenParameterivSGIS_ovr_0(pname, ¶ms);
private static procedure z_GetPixelTexGenParameterivSGIS_ovr_2(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTexGenParameterivSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr) :=
z_GetPixelTexGenParameterivSGIS_ovr_2(pname, ¶ms);
private static procedure z_GetPixelTexGenParameterfvSGIS_ovr_0(pname: PixelTexGenParameterNameSGIS; var ¶ms: single);
external 'opengl32.dll' name 'glGetPixelTexGenParameterfvSGIS';
private static procedure z_GetPixelTexGenParameterfvSGIS_ovr_0_anh001(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTexGenParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetPixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms[0]) else
z_GetPixelTexGenParameterfvSGIS_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: single) :=
z_GetPixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms);
private static procedure z_GetPixelTexGenParameterfvSGIS_ovr_2(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPixelTexGenParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr) :=
z_GetPixelTexGenParameterfvSGIS_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glPointParametersSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PointParameterfSGIS_ovr_0(pname: PointParameterNameARB; param: single);
external 'opengl32.dll' name 'glPointParameterfSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfSGIS(pname: PointParameterNameARB; param: single) :=
z_PointParameterfSGIS_ovr_0(pname, param);
private static procedure z_PointParameterfvSGIS_ovr_0(pname: PointParameterNameARB; var ¶ms: single);
external 'opengl32.dll' name 'glPointParameterfvSGIS';
private static procedure z_PointParameterfvSGIS_ovr_0_anh001(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_PointParameterfvSGIS_ovr_0(pname, ¶ms[0]) else
z_PointParameterfvSGIS_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; var ¶ms: single) :=
z_PointParameterfvSGIS_ovr_0(pname, ¶ms);
private static procedure z_PointParameterfvSGIS_ovr_2(pname: PointParameterNameARB; ¶ms: IntPtr);
external 'opengl32.dll' name 'glPointParameterfvSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; ¶ms: IntPtr) :=
z_PointParameterfvSGIS_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glSharpenTextureSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SharpenTexFuncSGIS_ovr_0(target: TextureTarget; n: Int32; var points: single);
external 'opengl32.dll' name 'glSharpenTexFuncSGIS';
private static procedure z_SharpenTexFuncSGIS_ovr_0_anh0001(target: TextureTarget; n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glSharpenTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_SharpenTexFuncSGIS_ovr_0(target, n, points[0]) else
z_SharpenTexFuncSGIS_ovr_0_anh0001(target, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; var points: single) :=
z_SharpenTexFuncSGIS_ovr_0(target, n, points);
private static procedure z_SharpenTexFuncSGIS_ovr_2(target: TextureTarget; n: Int32; points: IntPtr);
external 'opengl32.dll' name 'glSharpenTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; points: IntPtr) :=
z_SharpenTexFuncSGIS_ovr_2(target, n, points);
private static procedure z_GetSharpenTexFuncSGIS_ovr_0(target: TextureTarget; var points: single);
external 'opengl32.dll' name 'glGetSharpenTexFuncSGIS';
private static procedure z_GetSharpenTexFuncSGIS_ovr_0_anh001(target: TextureTarget; points: IntPtr);
external 'opengl32.dll' name 'glGetSharpenTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_GetSharpenTexFuncSGIS_ovr_0(target, points[0]) else
z_GetSharpenTexFuncSGIS_ovr_0_anh001(target, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; var points: single) :=
z_GetSharpenTexFuncSGIS_ovr_0(target, points);
private static procedure z_GetSharpenTexFuncSGIS_ovr_2(target: TextureTarget; points: IntPtr);
external 'opengl32.dll' name 'glGetSharpenTexFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; points: IntPtr) :=
z_GetSharpenTexFuncSGIS_ovr_2(target, points);
end;
[PCUNotRestore]
glTexture4DSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TexImage4DSGIS_ovr_0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; size4d: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage4DSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage4DSGIS(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; size4d: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexImage4DSGIS_ovr_0(target, level, _internalformat, width, height, depth, size4d, border, format, &type, pixels);
private static procedure z_TexSubImage4DSGIS_ovr_0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; woffset: Int32; width: Int32; height: Int32; depth: Int32; size4d: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage4DSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage4DSGIS(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; woffset: Int32; width: Int32; height: Int32; depth: Int32; size4d: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) :=
z_TexSubImage4DSGIS_ovr_0(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, &type, pixels);
end;
[PCUNotRestore]
glTextureColorMaskSGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TextureColorMaskSGIS_ovr_0(red: boolean; green: boolean; blue: boolean; alpha: boolean);
external 'opengl32.dll' name 'glTextureColorMaskSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureColorMaskSGIS(red: boolean; green: boolean; blue: boolean; alpha: boolean) :=
z_TextureColorMaskSGIS_ovr_0(red, green, blue, alpha);
end;
[PCUNotRestore]
glTextureFilter4SGIS = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetTexFilterFuncSGIS_ovr_0(target: TextureTarget; filter: TextureFilterSGIS; var weights: single);
external 'opengl32.dll' name 'glGetTexFilterFuncSGIS';
private static procedure z_GetTexFilterFuncSGIS_ovr_0_anh0001(target: TextureTarget; filter: TextureFilterSGIS; weights: IntPtr);
external 'opengl32.dll' name 'glGetTexFilterFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; weights: array of single) :=
if (weights<>nil) and (weights.Length<>0) then
z_GetTexFilterFuncSGIS_ovr_0(target, filter, weights[0]) else
z_GetTexFilterFuncSGIS_ovr_0_anh0001(target, filter, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; var weights: single) :=
z_GetTexFilterFuncSGIS_ovr_0(target, filter, weights);
private static procedure z_GetTexFilterFuncSGIS_ovr_2(target: TextureTarget; filter: TextureFilterSGIS; weights: IntPtr);
external 'opengl32.dll' name 'glGetTexFilterFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; weights: IntPtr) :=
z_GetTexFilterFuncSGIS_ovr_2(target, filter, weights);
private static procedure z_TexFilterFuncSGIS_ovr_0(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; var weights: single);
external 'opengl32.dll' name 'glTexFilterFuncSGIS';
private static procedure z_TexFilterFuncSGIS_ovr_0_anh00001(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glTexFilterFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: array of single) :=
if (weights<>nil) and (weights.Length<>0) then
z_TexFilterFuncSGIS_ovr_0(target, filter, n, weights[0]) else
z_TexFilterFuncSGIS_ovr_0_anh00001(target, filter, n, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; var weights: single) :=
z_TexFilterFuncSGIS_ovr_0(target, filter, n, weights);
private static procedure z_TexFilterFuncSGIS_ovr_2(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: IntPtr);
external 'opengl32.dll' name 'glTexFilterFuncSGIS';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: IntPtr) :=
z_TexFilterFuncSGIS_ovr_2(target, filter, n, weights);
end;
[PCUNotRestore]
glAsyncSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_AsyncMarkerSGIX_ovr_0(marker: UInt32);
external 'opengl32.dll' name 'glAsyncMarkerSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AsyncMarkerSGIX(marker: UInt32) :=
z_AsyncMarkerSGIX_ovr_0(marker);
private static function z_FinishAsyncSGIX_ovr_0(var markerp: UInt32): Int32;
external 'opengl32.dll' name 'glFinishAsyncSGIX';
private static function z_FinishAsyncSGIX_ovr_0_anh01(markerp: IntPtr): Int32;
external 'opengl32.dll' name 'glFinishAsyncSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(markerp: array of UInt32): Int32 :=
if (markerp<>nil) and (markerp.Length<>0) then
z_FinishAsyncSGIX_ovr_0(markerp[0]) else
z_FinishAsyncSGIX_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(var markerp: UInt32): Int32 :=
z_FinishAsyncSGIX_ovr_0(markerp);
private static function z_FinishAsyncSGIX_ovr_2(markerp: IntPtr): Int32;
external 'opengl32.dll' name 'glFinishAsyncSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(markerp: IntPtr): Int32 :=
z_FinishAsyncSGIX_ovr_2(markerp);
private static function z_PollAsyncSGIX_ovr_0(var markerp: UInt32): Int32;
external 'opengl32.dll' name 'glPollAsyncSGIX';
private static function z_PollAsyncSGIX_ovr_0_anh01(markerp: IntPtr): Int32;
external 'opengl32.dll' name 'glPollAsyncSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(markerp: array of UInt32): Int32 :=
if (markerp<>nil) and (markerp.Length<>0) then
z_PollAsyncSGIX_ovr_0(markerp[0]) else
z_PollAsyncSGIX_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(var markerp: UInt32): Int32 :=
z_PollAsyncSGIX_ovr_0(markerp);
private static function z_PollAsyncSGIX_ovr_2(markerp: IntPtr): Int32;
external 'opengl32.dll' name 'glPollAsyncSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(markerp: IntPtr): Int32 :=
z_PollAsyncSGIX_ovr_2(markerp);
private static function z_GenAsyncMarkersSGIX_ovr_0(range: Int32): UInt32;
external 'opengl32.dll' name 'glGenAsyncMarkersSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenAsyncMarkersSGIX(range: Int32): UInt32 :=
z_GenAsyncMarkersSGIX_ovr_0(range);
private static procedure z_DeleteAsyncMarkersSGIX_ovr_0(marker: UInt32; range: Int32);
external 'opengl32.dll' name 'glDeleteAsyncMarkersSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteAsyncMarkersSGIX(marker: UInt32; range: Int32) :=
z_DeleteAsyncMarkersSGIX_ovr_0(marker, range);
private static function z_IsAsyncMarkerSGIX_ovr_0(marker: UInt32): boolean;
external 'opengl32.dll' name 'glIsAsyncMarkerSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsAsyncMarkerSGIX(marker: UInt32): boolean :=
z_IsAsyncMarkerSGIX_ovr_0(marker);
end;
[PCUNotRestore]
glFlushRasterSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FlushRasterSGIX_ovr_0;
external 'opengl32.dll' name 'glFlushRasterSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushRasterSGIX :=
z_FlushRasterSGIX_ovr_0;
end;
[PCUNotRestore]
glFragmentLightingSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FragmentColorMaterialSGIX_ovr_0(face: MaterialFace; mode: MaterialParameter);
external 'opengl32.dll' name 'glFragmentColorMaterialSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentColorMaterialSGIX(face: MaterialFace; mode: MaterialParameter) :=
z_FragmentColorMaterialSGIX_ovr_0(face, mode);
private static procedure z_FragmentLightfSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: single);
external 'opengl32.dll' name 'glFragmentLightfSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: single) :=
z_FragmentLightfSGIX_ovr_0(light, pname, param);
private static procedure z_FragmentLightfvSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single);
external 'opengl32.dll' name 'glFragmentLightfvSGIX';
private static procedure z_FragmentLightfvSGIX_ovr_0_anh0001(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentLightfvSGIX_ovr_0(light, pname, ¶ms[0]) else
z_FragmentLightfvSGIX_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single) :=
z_FragmentLightfvSGIX_ovr_0(light, pname, ¶ms);
private static procedure z_FragmentLightfvSGIX_ovr_2(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr) :=
z_FragmentLightfvSGIX_ovr_2(light, pname, ¶ms);
private static procedure z_FragmentLightiSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: Int32);
external 'opengl32.dll' name 'glFragmentLightiSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightiSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: Int32) :=
z_FragmentLightiSGIX_ovr_0(light, pname, param);
private static procedure z_FragmentLightivSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32);
external 'opengl32.dll' name 'glFragmentLightivSGIX';
private static procedure z_FragmentLightivSGIX_ovr_0_anh0001(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentLightivSGIX_ovr_0(light, pname, ¶ms[0]) else
z_FragmentLightivSGIX_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32) :=
z_FragmentLightivSGIX_ovr_0(light, pname, ¶ms);
private static procedure z_FragmentLightivSGIX_ovr_2(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr) :=
z_FragmentLightivSGIX_ovr_2(light, pname, ¶ms);
private static procedure z_FragmentLightModelfSGIX_ovr_0(pname: FragmentLightModelParameterSGIX; param: single);
external 'opengl32.dll' name 'glFragmentLightModelfSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfSGIX(pname: FragmentLightModelParameterSGIX; param: single) :=
z_FragmentLightModelfSGIX_ovr_0(pname, param);
private static procedure z_FragmentLightModelfvSGIX_ovr_0(pname: FragmentLightModelParameterSGIX; var ¶ms: single);
external 'opengl32.dll' name 'glFragmentLightModelfvSGIX';
private static procedure z_FragmentLightModelfvSGIX_ovr_0_anh001(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightModelfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentLightModelfvSGIX_ovr_0(pname, ¶ms[0]) else
z_FragmentLightModelfvSGIX_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; var ¶ms: single) :=
z_FragmentLightModelfvSGIX_ovr_0(pname, ¶ms);
private static procedure z_FragmentLightModelfvSGIX_ovr_2(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightModelfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr) :=
z_FragmentLightModelfvSGIX_ovr_2(pname, ¶ms);
private static procedure z_FragmentLightModeliSGIX_ovr_0(pname: FragmentLightModelParameterSGIX; param: Int32);
external 'opengl32.dll' name 'glFragmentLightModeliSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModeliSGIX(pname: FragmentLightModelParameterSGIX; param: Int32) :=
z_FragmentLightModeliSGIX_ovr_0(pname, param);
private static procedure z_FragmentLightModelivSGIX_ovr_0(pname: FragmentLightModelParameterSGIX; var ¶ms: Int32);
external 'opengl32.dll' name 'glFragmentLightModelivSGIX';
private static procedure z_FragmentLightModelivSGIX_ovr_0_anh001(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightModelivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentLightModelivSGIX_ovr_0(pname, ¶ms[0]) else
z_FragmentLightModelivSGIX_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; var ¶ms: Int32) :=
z_FragmentLightModelivSGIX_ovr_0(pname, ¶ms);
private static procedure z_FragmentLightModelivSGIX_ovr_2(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentLightModelivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr) :=
z_FragmentLightModelivSGIX_ovr_2(pname, ¶ms);
private static procedure z_FragmentMaterialfSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; param: single);
external 'opengl32.dll' name 'glFragmentMaterialfSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfSGIX(face: MaterialFace; pname: MaterialParameter; param: single) :=
z_FragmentMaterialfSGIX_ovr_0(face, pname, param);
private static procedure z_FragmentMaterialfvSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glFragmentMaterialfvSGIX';
private static procedure z_FragmentMaterialfvSGIX_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentMaterialfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms[0]) else
z_FragmentMaterialfvSGIX_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; var ¶ms: single) :=
z_FragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms);
private static procedure z_FragmentMaterialfvSGIX_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentMaterialfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_FragmentMaterialfvSGIX_ovr_2(face, pname, ¶ms);
private static procedure z_FragmentMaterialiSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; param: Int32);
external 'opengl32.dll' name 'glFragmentMaterialiSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialiSGIX(face: MaterialFace; pname: MaterialParameter; param: Int32) :=
z_FragmentMaterialiSGIX_ovr_0(face, pname, param);
private static procedure z_FragmentMaterialivSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glFragmentMaterialivSGIX';
private static procedure z_FragmentMaterialivSGIX_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentMaterialivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_FragmentMaterialivSGIX_ovr_0(face, pname, ¶ms[0]) else
z_FragmentMaterialivSGIX_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32) :=
z_FragmentMaterialivSGIX_ovr_0(face, pname, ¶ms);
private static procedure z_FragmentMaterialivSGIX_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFragmentMaterialivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_FragmentMaterialivSGIX_ovr_2(face, pname, ¶ms);
private static procedure z_GetFragmentLightfvSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single);
external 'opengl32.dll' name 'glGetFragmentLightfvSGIX';
private static procedure z_GetFragmentLightfvSGIX_ovr_0_anh0001(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentLightfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFragmentLightfvSGIX_ovr_0(light, pname, ¶ms[0]) else
z_GetFragmentLightfvSGIX_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single) :=
z_GetFragmentLightfvSGIX_ovr_0(light, pname, ¶ms);
private static procedure z_GetFragmentLightfvSGIX_ovr_2(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentLightfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr) :=
z_GetFragmentLightfvSGIX_ovr_2(light, pname, ¶ms);
private static procedure z_GetFragmentLightivSGIX_ovr_0(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFragmentLightivSGIX';
private static procedure z_GetFragmentLightivSGIX_ovr_0_anh0001(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentLightivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFragmentLightivSGIX_ovr_0(light, pname, ¶ms[0]) else
z_GetFragmentLightivSGIX_ovr_0_anh0001(light, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32) :=
z_GetFragmentLightivSGIX_ovr_0(light, pname, ¶ms);
private static procedure z_GetFragmentLightivSGIX_ovr_2(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentLightivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr) :=
z_GetFragmentLightivSGIX_ovr_2(light, pname, ¶ms);
private static procedure z_GetFragmentMaterialfvSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetFragmentMaterialfvSGIX';
private static procedure z_GetFragmentMaterialfvSGIX_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentMaterialfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms[0]) else
z_GetFragmentMaterialfvSGIX_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; var ¶ms: single) :=
z_GetFragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms);
private static procedure z_GetFragmentMaterialfvSGIX_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentMaterialfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_GetFragmentMaterialfvSGIX_ovr_2(face, pname, ¶ms);
private static procedure z_GetFragmentMaterialivSGIX_ovr_0(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetFragmentMaterialivSGIX';
private static procedure z_GetFragmentMaterialivSGIX_ovr_0_anh0001(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentMaterialivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetFragmentMaterialivSGIX_ovr_0(face, pname, ¶ms[0]) else
z_GetFragmentMaterialivSGIX_ovr_0_anh0001(face, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; var ¶ms: Int32) :=
z_GetFragmentMaterialivSGIX_ovr_0(face, pname, ¶ms);
private static procedure z_GetFragmentMaterialivSGIX_ovr_2(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetFragmentMaterialivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: MaterialFace; pname: MaterialParameter; ¶ms: IntPtr) :=
z_GetFragmentMaterialivSGIX_ovr_2(face, pname, ¶ms);
private static procedure z_LightEnviSGIX_ovr_0(pname: LightEnvParameterSGIX; param: Int32);
external 'opengl32.dll' name 'glLightEnviSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightEnviSGIX(pname: LightEnvParameterSGIX; param: Int32) :=
z_LightEnviSGIX_ovr_0(pname, param);
end;
[PCUNotRestore]
glFramezoomSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FrameZoomSGIX_ovr_0(factor: Int32);
external 'opengl32.dll' name 'glFrameZoomSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrameZoomSGIX(factor: Int32) :=
z_FrameZoomSGIX_ovr_0(factor);
end;
[PCUNotRestore]
glIglooInterfaceSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_IglooInterfaceSGIX_ovr_0(pname: DummyEnum; ¶ms: IntPtr);
external 'opengl32.dll' name 'glIglooInterfaceSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IglooInterfaceSGIX(pname: DummyEnum; ¶ms: IntPtr) :=
z_IglooInterfaceSGIX_ovr_0(pname, ¶ms);
end;
[PCUNotRestore]
glInstrumentsSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static function z_GetInstrumentsSGIX_ovr_0: Int32;
external 'opengl32.dll' name 'glGetInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetInstrumentsSGIX: Int32 :=
z_GetInstrumentsSGIX_ovr_0;
private static procedure z_InstrumentsBufferSGIX_ovr_0(size: Int32; var buffer: Int32);
external 'opengl32.dll' name 'glInstrumentsBufferSGIX';
private static procedure z_InstrumentsBufferSGIX_ovr_0_anh001(size: Int32; buffer: IntPtr);
external 'opengl32.dll' name 'glInstrumentsBufferSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; buffer: array of Int32) :=
if (buffer<>nil) and (buffer.Length<>0) then
z_InstrumentsBufferSGIX_ovr_0(size, buffer[0]) else
z_InstrumentsBufferSGIX_ovr_0_anh001(size, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; var buffer: Int32) :=
z_InstrumentsBufferSGIX_ovr_0(size, buffer);
private static procedure z_InstrumentsBufferSGIX_ovr_2(size: Int32; buffer: IntPtr);
external 'opengl32.dll' name 'glInstrumentsBufferSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; buffer: IntPtr) :=
z_InstrumentsBufferSGIX_ovr_2(size, buffer);
private static function z_PollInstrumentsSGIX_ovr_0(var marker_p: Int32): Int32;
external 'opengl32.dll' name 'glPollInstrumentsSGIX';
private static function z_PollInstrumentsSGIX_ovr_0_anh01(marker_p: IntPtr): Int32;
external 'opengl32.dll' name 'glPollInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(marker_p: array of Int32): Int32 :=
if (marker_p<>nil) and (marker_p.Length<>0) then
z_PollInstrumentsSGIX_ovr_0(marker_p[0]) else
z_PollInstrumentsSGIX_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(var marker_p: Int32): Int32 :=
z_PollInstrumentsSGIX_ovr_0(marker_p);
private static function z_PollInstrumentsSGIX_ovr_2(marker_p: IntPtr): Int32;
external 'opengl32.dll' name 'glPollInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(marker_p: IntPtr): Int32 :=
z_PollInstrumentsSGIX_ovr_2(marker_p);
private static procedure z_ReadInstrumentsSGIX_ovr_0(marker: Int32);
external 'opengl32.dll' name 'glReadInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadInstrumentsSGIX(marker: Int32) :=
z_ReadInstrumentsSGIX_ovr_0(marker);
private static procedure z_StartInstrumentsSGIX_ovr_0;
external 'opengl32.dll' name 'glStartInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StartInstrumentsSGIX :=
z_StartInstrumentsSGIX_ovr_0;
private static procedure z_StopInstrumentsSGIX_ovr_0(marker: Int32);
external 'opengl32.dll' name 'glStopInstrumentsSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StopInstrumentsSGIX(marker: Int32) :=
z_StopInstrumentsSGIX_ovr_0(marker);
end;
[PCUNotRestore]
glListPrioritySGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GetListParameterfvSGIX_ovr_0(list: UInt32; pname: ListParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glGetListParameterfvSGIX';
private static procedure z_GetListParameterfvSGIX_ovr_0_anh0001(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetListParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetListParameterfvSGIX_ovr_0(list, pname, ¶ms[0]) else
z_GetListParameterfvSGIX_ovr_0_anh0001(list, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; var ¶ms: single) :=
z_GetListParameterfvSGIX_ovr_0(list, pname, ¶ms);
private static procedure z_GetListParameterfvSGIX_ovr_2(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetListParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr) :=
z_GetListParameterfvSGIX_ovr_2(list, pname, ¶ms);
private static procedure z_GetListParameterivSGIX_ovr_0(list: UInt32; pname: ListParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetListParameterivSGIX';
private static procedure z_GetListParameterivSGIX_ovr_0_anh0001(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetListParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetListParameterivSGIX_ovr_0(list, pname, ¶ms[0]) else
z_GetListParameterivSGIX_ovr_0_anh0001(list, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; var ¶ms: Int32) :=
z_GetListParameterivSGIX_ovr_0(list, pname, ¶ms);
private static procedure z_GetListParameterivSGIX_ovr_2(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetListParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr) :=
z_GetListParameterivSGIX_ovr_2(list, pname, ¶ms);
private static procedure z_ListParameterfSGIX_ovr_0(list: UInt32; pname: ListParameterName; param: single);
external 'opengl32.dll' name 'glListParameterfSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfSGIX(list: UInt32; pname: ListParameterName; param: single) :=
z_ListParameterfSGIX_ovr_0(list, pname, param);
private static procedure z_ListParameterfvSGIX_ovr_0(list: UInt32; pname: ListParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glListParameterfvSGIX';
private static procedure z_ListParameterfvSGIX_ovr_0_anh0001(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glListParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ListParameterfvSGIX_ovr_0(list, pname, ¶ms[0]) else
z_ListParameterfvSGIX_ovr_0_anh0001(list, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; var ¶ms: single) :=
z_ListParameterfvSGIX_ovr_0(list, pname, ¶ms);
private static procedure z_ListParameterfvSGIX_ovr_2(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glListParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr) :=
z_ListParameterfvSGIX_ovr_2(list, pname, ¶ms);
private static procedure z_ListParameteriSGIX_ovr_0(list: UInt32; pname: ListParameterName; param: Int32);
external 'opengl32.dll' name 'glListParameteriSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameteriSGIX(list: UInt32; pname: ListParameterName; param: Int32) :=
z_ListParameteriSGIX_ovr_0(list, pname, param);
private static procedure z_ListParameterivSGIX_ovr_0(list: UInt32; pname: ListParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glListParameterivSGIX';
private static procedure z_ListParameterivSGIX_ovr_0_anh0001(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glListParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ListParameterivSGIX_ovr_0(list, pname, ¶ms[0]) else
z_ListParameterivSGIX_ovr_0_anh0001(list, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; var ¶ms: Int32) :=
z_ListParameterivSGIX_ovr_0(list, pname, ¶ms);
private static procedure z_ListParameterivSGIX_ovr_2(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glListParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr) :=
z_ListParameterivSGIX_ovr_2(list, pname, ¶ms);
end;
[PCUNotRestore]
glPixelTextureSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_PixelTexGenSGIX_ovr_0(mode: PixelTexGenModeSGIX);
external 'opengl32.dll' name 'glPixelTexGenSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenSGIX(mode: PixelTexGenModeSGIX) :=
z_PixelTexGenSGIX_ovr_0(mode);
end;
[PCUNotRestore]
glPolynomialFfdSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DeformationMap3dSGIX_ovr_0(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; var points: real);
external 'opengl32.dll' name 'glDeformationMap3dSGIX';
private static procedure z_DeformationMap3dSGIX_ovr_0_anh000000000000001(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDeformationMap3dSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3dSGIX(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; points: array of real) :=
if (points<>nil) and (points.Length<>0) then
z_DeformationMap3dSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points[0]) else
z_DeformationMap3dSGIX_ovr_0_anh000000000000001(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3dSGIX(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; var points: real) :=
z_DeformationMap3dSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
private static procedure z_DeformationMap3dSGIX_ovr_2(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDeformationMap3dSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3dSGIX(target: FfdTargetSGIX; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; w1: real; w2: real; wstride: Int32; worder: Int32; points: IntPtr) :=
z_DeformationMap3dSGIX_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
private static procedure z_DeformationMap3fSGIX_ovr_0(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; var points: single);
external 'opengl32.dll' name 'glDeformationMap3fSGIX';
private static procedure z_DeformationMap3fSGIX_ovr_0_anh000000000000001(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDeformationMap3fSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3fSGIX(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; points: array of single) :=
if (points<>nil) and (points.Length<>0) then
z_DeformationMap3fSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points[0]) else
z_DeformationMap3fSGIX_ovr_0_anh000000000000001(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3fSGIX(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; var points: single) :=
z_DeformationMap3fSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
private static procedure z_DeformationMap3fSGIX_ovr_2(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; points: IntPtr);
external 'opengl32.dll' name 'glDeformationMap3fSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformationMap3fSGIX(target: FfdTargetSGIX; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; w1: single; w2: single; wstride: Int32; worder: Int32; points: IntPtr) :=
z_DeformationMap3fSGIX_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
private static procedure z_DeformSGIX_ovr_0(mask: FfdMaskSGIX);
external 'opengl32.dll' name 'glDeformSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformSGIX(mask: FfdMaskSGIX) :=
z_DeformSGIX_ovr_0(mask);
private static procedure z_LoadIdentityDeformationMapSGIX_ovr_0(mask: FfdMaskSGIX);
external 'opengl32.dll' name 'glLoadIdentityDeformationMapSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadIdentityDeformationMapSGIX(mask: FfdMaskSGIX) :=
z_LoadIdentityDeformationMapSGIX_ovr_0(mask);
end;
[PCUNotRestore]
glReferencePlaneSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ReferencePlaneSGIX_ovr_0(var equation: real);
external 'opengl32.dll' name 'glReferencePlaneSGIX';
private static procedure z_ReferencePlaneSGIX_ovr_0_anh01(equation: IntPtr);
external 'opengl32.dll' name 'glReferencePlaneSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(equation: array of real) :=
if (equation<>nil) and (equation.Length<>0) then
z_ReferencePlaneSGIX_ovr_0(equation[0]) else
z_ReferencePlaneSGIX_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(var equation: real) :=
z_ReferencePlaneSGIX_ovr_0(equation);
private static procedure z_ReferencePlaneSGIX_ovr_2(equation: IntPtr);
external 'opengl32.dll' name 'glReferencePlaneSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(equation: IntPtr) :=
z_ReferencePlaneSGIX_ovr_2(equation);
end;
[PCUNotRestore]
glSpriteSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_SpriteParameterfSGIX_ovr_0(pname: SpriteParameterNameSGIX; param: single);
external 'opengl32.dll' name 'glSpriteParameterfSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfSGIX(pname: SpriteParameterNameSGIX; param: single) :=
z_SpriteParameterfSGIX_ovr_0(pname, param);
private static procedure z_SpriteParameterfvSGIX_ovr_0(pname: SpriteParameterNameSGIX; var ¶ms: single);
external 'opengl32.dll' name 'glSpriteParameterfvSGIX';
private static procedure z_SpriteParameterfvSGIX_ovr_0_anh001(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSpriteParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_SpriteParameterfvSGIX_ovr_0(pname, ¶ms[0]) else
z_SpriteParameterfvSGIX_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; var ¶ms: single) :=
z_SpriteParameterfvSGIX_ovr_0(pname, ¶ms);
private static procedure z_SpriteParameterfvSGIX_ovr_2(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSpriteParameterfvSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; ¶ms: IntPtr) :=
z_SpriteParameterfvSGIX_ovr_2(pname, ¶ms);
private static procedure z_SpriteParameteriSGIX_ovr_0(pname: SpriteParameterNameSGIX; param: Int32);
external 'opengl32.dll' name 'glSpriteParameteriSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameteriSGIX(pname: SpriteParameterNameSGIX; param: Int32) :=
z_SpriteParameteriSGIX_ovr_0(pname, param);
private static procedure z_SpriteParameterivSGIX_ovr_0(pname: SpriteParameterNameSGIX; var ¶ms: Int32);
external 'opengl32.dll' name 'glSpriteParameterivSGIX';
private static procedure z_SpriteParameterivSGIX_ovr_0_anh001(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSpriteParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_SpriteParameterivSGIX_ovr_0(pname, ¶ms[0]) else
z_SpriteParameterivSGIX_ovr_0_anh001(pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; var ¶ms: Int32) :=
z_SpriteParameterivSGIX_ovr_0(pname, ¶ms);
private static procedure z_SpriteParameterivSGIX_ovr_2(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
external 'opengl32.dll' name 'glSpriteParameterivSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; ¶ms: IntPtr) :=
z_SpriteParameterivSGIX_ovr_2(pname, ¶ms);
end;
[PCUNotRestore]
glTagSampleBufferSGIX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_TagSampleBufferSGIX_ovr_0;
external 'opengl32.dll' name 'glTagSampleBufferSGIX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TagSampleBufferSGIX :=
z_TagSampleBufferSGIX_ovr_0;
end;
[PCUNotRestore]
glColorTableSGI = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ColorTableSGI_ovr_0(target: ColorTableTargetSGI; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr);
external 'opengl32.dll' name 'glColorTableSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableSGI(target: ColorTableTargetSGI; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr) :=
z_ColorTableSGI_ovr_0(target, _internalformat, width, format, &type, table);
private static procedure z_ColorTableParameterfvSGI_ovr_0(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; var ¶ms: single);
external 'opengl32.dll' name 'glColorTableParameterfvSGI';
private static procedure z_ColorTableParameterfvSGI_ovr_0_anh0001(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterfvSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ColorTableParameterfvSGI_ovr_0(target, pname, ¶ms[0]) else
z_ColorTableParameterfvSGI_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; var ¶ms: single) :=
z_ColorTableParameterfvSGI_ovr_0(target, pname, ¶ms);
private static procedure z_ColorTableParameterfvSGI_ovr_2(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterfvSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_ColorTableParameterfvSGI_ovr_2(target, pname, ¶ms);
private static procedure z_ColorTableParameterivSGI_ovr_0(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; var ¶ms: Int32);
external 'opengl32.dll' name 'glColorTableParameterivSGI';
private static procedure z_ColorTableParameterivSGI_ovr_0_anh0001(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterivSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_ColorTableParameterivSGI_ovr_0(target, pname, ¶ms[0]) else
z_ColorTableParameterivSGI_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; var ¶ms: Int32) :=
z_ColorTableParameterivSGI_ovr_0(target, pname, ¶ms);
private static procedure z_ColorTableParameterivSGI_ovr_2(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glColorTableParameterivSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: ColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_ColorTableParameterivSGI_ovr_2(target, pname, ¶ms);
private static procedure z_CopyColorTableSGI_ovr_0(target: ColorTableTargetSGI; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyColorTableSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorTableSGI(target: ColorTableTargetSGI; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32) :=
z_CopyColorTableSGI_ovr_0(target, _internalformat, x, y, width);
private static procedure z_GetColorTableSGI_ovr_0(target: ColorTableTargetSGI; format: PixelFormat; &type: PixelType; table: IntPtr);
external 'opengl32.dll' name 'glGetColorTableSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableSGI(target: ColorTableTargetSGI; format: PixelFormat; &type: PixelType; table: IntPtr) :=
z_GetColorTableSGI_ovr_0(target, format, &type, table);
private static procedure z_GetColorTableParameterfvSGI_ovr_0(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: single);
external 'opengl32.dll' name 'glGetColorTableParameterfvSGI';
private static procedure z_GetColorTableParameterfvSGI_ovr_0_anh0001(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfvSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: array of single) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameterfvSGI_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameterfvSGI_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: single) :=
z_GetColorTableParameterfvSGI_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameterfvSGI_ovr_2(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterfvSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameterfvSGI_ovr_2(target, pname, ¶ms);
private static procedure z_GetColorTableParameterivSGI_ovr_0(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetColorTableParameterivSGI';
private static procedure z_GetColorTableParameterivSGI_ovr_0_anh0001(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterivSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: array of Int32) :=
if (¶ms<>nil) and (¶ms.Length<>0) then
z_GetColorTableParameterivSGI_ovr_0(target, pname, ¶ms[0]) else
z_GetColorTableParameterivSGI_ovr_0_anh0001(target, pname, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32) :=
z_GetColorTableParameterivSGI_ovr_0(target, pname, ¶ms);
private static procedure z_GetColorTableParameterivSGI_ovr_2(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetColorTableParameterivSGI';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr) :=
z_GetColorTableParameterivSGI_ovr_2(target, pname, ¶ms);
end;
[PCUNotRestore]
glConstantDataSUNX = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_FinishTextureSUNX_ovr_0;
external 'opengl32.dll' name 'glFinishTextureSUNX';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishTextureSUNX :=
z_FinishTextureSUNX_ovr_0;
end;
[PCUNotRestore]
glGlobalAlphaSUN = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_GlobalAlphaFactorbSUN_ovr_0(factor: SByte);
external 'opengl32.dll' name 'glGlobalAlphaFactorbSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorbSUN(factor: SByte) :=
z_GlobalAlphaFactorbSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactorsSUN_ovr_0(factor: Int16);
external 'opengl32.dll' name 'glGlobalAlphaFactorsSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorsSUN(factor: Int16) :=
z_GlobalAlphaFactorsSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactoriSUN_ovr_0(factor: Int32);
external 'opengl32.dll' name 'glGlobalAlphaFactoriSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactoriSUN(factor: Int32) :=
z_GlobalAlphaFactoriSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactorfSUN_ovr_0(factor: single);
external 'opengl32.dll' name 'glGlobalAlphaFactorfSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorfSUN(factor: single) :=
z_GlobalAlphaFactorfSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactordSUN_ovr_0(factor: real);
external 'opengl32.dll' name 'glGlobalAlphaFactordSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactordSUN(factor: real) :=
z_GlobalAlphaFactordSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactorubSUN_ovr_0(factor: Byte);
external 'opengl32.dll' name 'glGlobalAlphaFactorubSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorubSUN(factor: Byte) :=
z_GlobalAlphaFactorubSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactorusSUN_ovr_0(factor: UInt16);
external 'opengl32.dll' name 'glGlobalAlphaFactorusSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorusSUN(factor: UInt16) :=
z_GlobalAlphaFactorusSUN_ovr_0(factor);
private static procedure z_GlobalAlphaFactoruiSUN_ovr_0(factor: UInt32);
external 'opengl32.dll' name 'glGlobalAlphaFactoruiSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactoruiSUN(factor: UInt32) :=
z_GlobalAlphaFactoruiSUN_ovr_0(factor);
end;
[PCUNotRestore]
glMeshArraySUN = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_DrawMeshArraysSUN_ovr_0(mode: PrimitiveType; first: Int32; count: Int32; width: Int32);
external 'opengl32.dll' name 'glDrawMeshArraysSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshArraysSUN(mode: PrimitiveType; first: Int32; count: Int32; width: Int32) :=
z_DrawMeshArraysSUN_ovr_0(mode, first, count, width);
end;
[PCUNotRestore]
glTriangleListSUN = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_ReplacementCodeuiSUN_ovr_0(code: UInt32);
external 'opengl32.dll' name 'glReplacementCodeuiSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiSUN(code: UInt32) :=
z_ReplacementCodeuiSUN_ovr_0(code);
private static procedure z_ReplacementCodeusSUN_ovr_0(code: UInt16);
external 'opengl32.dll' name 'glReplacementCodeusSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusSUN(code: UInt16) :=
z_ReplacementCodeusSUN_ovr_0(code);
private static procedure z_ReplacementCodeubSUN_ovr_0(code: Byte);
external 'opengl32.dll' name 'glReplacementCodeubSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubSUN(code: Byte) :=
z_ReplacementCodeubSUN_ovr_0(code);
private static procedure z_ReplacementCodeuivSUN_ovr_0(var code: UInt32);
external 'opengl32.dll' name 'glReplacementCodeuivSUN';
private static procedure z_ReplacementCodeuivSUN_ovr_0_anh01(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuivSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(code: array of UInt32) :=
if (code<>nil) and (code.Length<>0) then
z_ReplacementCodeuivSUN_ovr_0(code[0]) else
z_ReplacementCodeuivSUN_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(var code: UInt32) :=
z_ReplacementCodeuivSUN_ovr_0(code);
private static procedure z_ReplacementCodeuivSUN_ovr_2(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuivSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(code: IntPtr) :=
z_ReplacementCodeuivSUN_ovr_2(code);
private static procedure z_ReplacementCodeusvSUN_ovr_0(var code: UInt16);
external 'opengl32.dll' name 'glReplacementCodeusvSUN';
private static procedure z_ReplacementCodeusvSUN_ovr_0_anh01(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeusvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(code: array of UInt16) :=
if (code<>nil) and (code.Length<>0) then
z_ReplacementCodeusvSUN_ovr_0(code[0]) else
z_ReplacementCodeusvSUN_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(var code: UInt16) :=
z_ReplacementCodeusvSUN_ovr_0(code);
private static procedure z_ReplacementCodeusvSUN_ovr_2(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeusvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(code: IntPtr) :=
z_ReplacementCodeusvSUN_ovr_2(code);
private static procedure z_ReplacementCodeubvSUN_ovr_0(var code: Byte);
external 'opengl32.dll' name 'glReplacementCodeubvSUN';
private static procedure z_ReplacementCodeubvSUN_ovr_0_anh01(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeubvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(code: array of Byte) :=
if (code<>nil) and (code.Length<>0) then
z_ReplacementCodeubvSUN_ovr_0(code[0]) else
z_ReplacementCodeubvSUN_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(var code: Byte) :=
z_ReplacementCodeubvSUN_ovr_0(code);
private static procedure z_ReplacementCodeubvSUN_ovr_2(code: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeubvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(code: IntPtr) :=
z_ReplacementCodeubvSUN_ovr_2(code);
private static procedure z_ReplacementCodePointerSUN_ovr_0(&type: ReplacementCodeTypeSUN; stride: Int32; var _pointer: IntPtr);
external 'opengl32.dll' name 'glReplacementCodePointerSUN';
private static procedure z_ReplacementCodePointerSUN_ovr_0_anh0001(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: IntPtr);
external 'opengl32.dll' name 'glReplacementCodePointerSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: array of IntPtr) :=
if (_pointer<>nil) and (_pointer.Length<>0) then
z_ReplacementCodePointerSUN_ovr_0(&type, stride, _pointer[0]) else
z_ReplacementCodePointerSUN_ovr_0_anh0001(&type, stride, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; var _pointer: IntPtr) :=
z_ReplacementCodePointerSUN_ovr_0(&type, stride, _pointer);
private static procedure z_ReplacementCodePointerSUN_ovr_2(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: pointer);
external 'opengl32.dll' name 'glReplacementCodePointerSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: pointer) :=
z_ReplacementCodePointerSUN_ovr_2(&type, stride, _pointer);
end;
[PCUNotRestore]
glVertexSUN = sealed class
public static function GetFuncAdr([MarshalAs(UnmanagedType.LPStr)] lpszProc: string): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static function GetFuncOrNil<T>(fadr: IntPtr) :=
fadr=IntPtr.Zero ? default(T) :
Marshal.GetDelegateForFunctionPointer&<T>(fadr);
private static procedure z_Color4ubVertex2fSUN_ovr_0(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single);
external 'opengl32.dll' name 'glColor4ubVertex2fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fSUN(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single) :=
z_Color4ubVertex2fSUN_ovr_0(r, g, b, a, x, y);
private static procedure z_Color4ubVertex2fvSUN_ovr_0(var c: Vec4ub; var v: Vec2f);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(var c: Vec4ub; var v: Vec2f) :=
z_Color4ubVertex2fvSUN_ovr_0(c, v);
private static procedure z_Color4ubVertex2fvSUN_ovr_1(var c: Byte; var v: single);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
private static procedure z_Color4ubVertex2fvSUN_ovr_1_anh010(c: IntPtr; var v: single);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
private static procedure z_Color4ubVertex2fvSUN_ovr_1_anh001(var c: Byte; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
private static procedure z_Color4ubVertex2fvSUN_ovr_1_anh011(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(c: array of Byte; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Color4ubVertex2fvSUN_ovr_1(c[0], v[0]) else
z_Color4ubVertex2fvSUN_ovr_1_anh001(c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Color4ubVertex2fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_Color4ubVertex2fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(var c: Byte; var v: single) :=
z_Color4ubVertex2fvSUN_ovr_1(c, v);
private static procedure z_Color4ubVertex2fvSUN_ovr_3(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex2fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(c: IntPtr; v: IntPtr) :=
z_Color4ubVertex2fvSUN_ovr_3(c, v);
private static procedure z_Color4ubVertex3fSUN_ovr_0(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
external 'opengl32.dll' name 'glColor4ubVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fSUN(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single) :=
z_Color4ubVertex3fSUN_ovr_0(r, g, b, a, x, y, z);
private static procedure z_Color4ubVertex3fvSUN_ovr_0(var c: Vec4ub; var v: Vec3f);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(var c: Vec4ub; var v: Vec3f) :=
z_Color4ubVertex3fvSUN_ovr_0(c, v);
private static procedure z_Color4ubVertex3fvSUN_ovr_1(var c: Byte; var v: single);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
private static procedure z_Color4ubVertex3fvSUN_ovr_1_anh010(c: IntPtr; var v: single);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
private static procedure z_Color4ubVertex3fvSUN_ovr_1_anh001(var c: Byte; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
private static procedure z_Color4ubVertex3fvSUN_ovr_1_anh011(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(c: array of Byte; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Color4ubVertex3fvSUN_ovr_1(c[0], v[0]) else
z_Color4ubVertex3fvSUN_ovr_1_anh001(c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Color4ubVertex3fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_Color4ubVertex3fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(var c: Byte; var v: single) :=
z_Color4ubVertex3fvSUN_ovr_1(c, v);
private static procedure z_Color4ubVertex3fvSUN_ovr_3(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(c: IntPtr; v: IntPtr) :=
z_Color4ubVertex3fvSUN_ovr_3(c, v);
private static procedure z_Color3fVertex3fSUN_ovr_0(r: single; g: single; b: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glColor3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fSUN(r: single; g: single; b: single; x: single; y: single; z: single) :=
z_Color3fVertex3fSUN_ovr_0(r, g, b, x, y, z);
private static procedure z_Color3fVertex3fvSUN_ovr_0(var c: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(var c: Vec3f; var v: Vec3f) :=
z_Color3fVertex3fvSUN_ovr_0(c, v);
private static procedure z_Color3fVertex3fvSUN_ovr_1(var c: single; var v: single);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
private static procedure z_Color3fVertex3fvSUN_ovr_1_anh010(c: IntPtr; var v: single);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
private static procedure z_Color3fVertex3fvSUN_ovr_1_anh001(var c: single; v: IntPtr);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
private static procedure z_Color3fVertex3fvSUN_ovr_1_anh011(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(c: array of single; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Color3fVertex3fvSUN_ovr_1(c[0], v[0]) else
z_Color3fVertex3fvSUN_ovr_1_anh001(c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Color3fVertex3fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_Color3fVertex3fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(var c: single; var v: single) :=
z_Color3fVertex3fvSUN_ovr_1(c, v);
private static procedure z_Color3fVertex3fvSUN_ovr_3(c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(c: IntPtr; v: IntPtr) :=
z_Color3fVertex3fvSUN_ovr_3(c, v);
private static procedure z_Normal3fVertex3fSUN_ovr_0(nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fSUN(nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_Normal3fVertex3fSUN_ovr_0(nx, ny, nz, x, y, z);
private static procedure z_Normal3fVertex3fvSUN_ovr_0(var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(var n: Vec3f; var v: Vec3f) :=
z_Normal3fVertex3fvSUN_ovr_0(n, v);
private static procedure z_Normal3fVertex3fvSUN_ovr_1(var n: single; var v: single);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
private static procedure z_Normal3fVertex3fvSUN_ovr_1_anh010(n: IntPtr; var v: single);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
private static procedure z_Normal3fVertex3fvSUN_ovr_1_anh001(var n: single; v: IntPtr);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
private static procedure z_Normal3fVertex3fvSUN_ovr_1_anh011(n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(n: array of single; v: array of single) :=
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Normal3fVertex3fvSUN_ovr_1(n[0], v[0]) else
z_Normal3fVertex3fvSUN_ovr_1_anh001(n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Normal3fVertex3fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_Normal3fVertex3fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(var n: single; var v: single) :=
z_Normal3fVertex3fvSUN_ovr_1(n, v);
private static procedure z_Normal3fVertex3fvSUN_ovr_3(n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(n: IntPtr; v: IntPtr) :=
z_Normal3fVertex3fvSUN_ovr_3(n, v);
private static procedure z_Color4fNormal3fVertex3fSUN_ovr_0(r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fSUN(r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_Color4fNormal3fVertex3fSUN_ovr_0(r, g, b, a, nx, ny, nz, x, y, z);
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_0(var c: Vec4f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(var c: Vec4f; var n: Vec3f; var v: Vec3f) :=
z_Color4fNormal3fVertex3fvSUN_ovr_0(c, n, v);
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1(var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0100(c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0010(var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0110(c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0001(var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0101(c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0011(var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0111(c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(c: array of single; n: array of single; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Color4fNormal3fVertex3fvSUN_ovr_1(c[0], n[0], v[0]) else
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0001(c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0010(c[0], IntPtr.Zero, v[0]) else
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0011(c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0100(IntPtr.Zero, n[0], v[0]) else
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0101(IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0110(IntPtr.Zero, IntPtr.Zero, v[0]) else
z_Color4fNormal3fVertex3fvSUN_ovr_1_anh0111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(var c: single; var n: single; var v: single) :=
z_Color4fNormal3fVertex3fvSUN_ovr_1(c, n, v);
private static procedure z_Color4fNormal3fVertex3fvSUN_ovr_3(c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(c: IntPtr; n: IntPtr; v: IntPtr) :=
z_Color4fNormal3fVertex3fvSUN_ovr_3(c, n, v);
private static procedure z_TexCoord2fVertex3fSUN_ovr_0(s: single; t: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glTexCoord2fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fSUN(s: single; t: single; x: single; y: single; z: single) :=
z_TexCoord2fVertex3fSUN_ovr_0(s, t, x, y, z);
private static procedure z_TexCoord2fVertex3fvSUN_ovr_0(var tc: Vec2f; var v: Vec3f);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(var tc: Vec2f; var v: Vec3f) :=
z_TexCoord2fVertex3fvSUN_ovr_0(tc, v);
private static procedure z_TexCoord2fVertex3fvSUN_ovr_1(var tc: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
private static procedure z_TexCoord2fVertex3fvSUN_ovr_1_anh010(tc: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
private static procedure z_TexCoord2fVertex3fvSUN_ovr_1_anh001(var tc: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
private static procedure z_TexCoord2fVertex3fvSUN_ovr_1_anh011(tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(tc: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fVertex3fvSUN_ovr_1(tc[0], v[0]) else
z_TexCoord2fVertex3fvSUN_ovr_1_anh001(tc[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fVertex3fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_TexCoord2fVertex3fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(var tc: single; var v: single) :=
z_TexCoord2fVertex3fvSUN_ovr_1(tc, v);
private static procedure z_TexCoord2fVertex3fvSUN_ovr_3(tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(tc: IntPtr; v: IntPtr) :=
z_TexCoord2fVertex3fvSUN_ovr_3(tc, v);
private static procedure z_TexCoord4fVertex4fSUN_ovr_0(s: single; t: single; p: single; q: single; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glTexCoord4fVertex4fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fSUN(s: single; t: single; p: single; q: single; x: single; y: single; z: single; w: single) :=
z_TexCoord4fVertex4fSUN_ovr_0(s, t, p, q, x, y, z, w);
private static procedure z_TexCoord4fVertex4fvSUN_ovr_0(var tc: Vec4f; var v: Vec4f);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(var tc: Vec4f; var v: Vec4f) :=
z_TexCoord4fVertex4fvSUN_ovr_0(tc, v);
private static procedure z_TexCoord4fVertex4fvSUN_ovr_1(var tc: single; var v: single);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
private static procedure z_TexCoord4fVertex4fvSUN_ovr_1_anh010(tc: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
private static procedure z_TexCoord4fVertex4fvSUN_ovr_1_anh001(var tc: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
private static procedure z_TexCoord4fVertex4fvSUN_ovr_1_anh011(tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(tc: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fVertex4fvSUN_ovr_1(tc[0], v[0]) else
z_TexCoord4fVertex4fvSUN_ovr_1_anh001(tc[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fVertex4fvSUN_ovr_1_anh010(IntPtr.Zero, v[0]) else
z_TexCoord4fVertex4fvSUN_ovr_1_anh011(IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(var tc: single; var v: single) :=
z_TexCoord4fVertex4fvSUN_ovr_1(tc, v);
private static procedure z_TexCoord4fVertex4fvSUN_ovr_3(tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(tc: IntPtr; v: IntPtr) :=
z_TexCoord4fVertex4fvSUN_ovr_3(tc, v);
private static procedure z_TexCoord2fColor4ubVertex3fSUN_ovr_0(s: single; t: single; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fSUN(s: single; t: single; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single) :=
z_TexCoord2fColor4ubVertex3fSUN_ovr_0(s, t, r, g, b, a, x, y, z);
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_0(var tc: Vec2f; var c: Vec4ub; var v: Vec3f);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(var tc: Vec2f; var c: Vec4ub; var v: Vec3f) :=
z_TexCoord2fColor4ubVertex3fvSUN_ovr_0(tc, c, v);
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1(var tc: single; var c: Byte; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0100(tc: IntPtr; var c: Byte; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0010(var tc: single; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0110(tc: IntPtr; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0001(var tc: single; var c: Byte; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0101(tc: IntPtr; var c: Byte; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0011(var tc: single; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0111(tc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(tc: array of single; c: array of Byte; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1(tc[0], c[0], v[0]) else
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0001(tc[0], c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0010(tc[0], IntPtr.Zero, v[0]) else
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0011(tc[0], IntPtr.Zero, IntPtr.Zero) else
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0100(IntPtr.Zero, c[0], v[0]) else
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0101(IntPtr.Zero, c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0110(IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1_anh0111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(var tc: single; var c: Byte; var v: single) :=
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1(tc, c, v);
private static procedure z_TexCoord2fColor4ubVertex3fvSUN_ovr_3(tc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(tc: IntPtr; c: IntPtr; v: IntPtr) :=
z_TexCoord2fColor4ubVertex3fvSUN_ovr_3(tc, c, v);
private static procedure z_TexCoord2fColor3fVertex3fSUN_ovr_0(s: single; t: single; r: single; g: single; b: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fSUN(s: single; t: single; r: single; g: single; b: single; x: single; y: single; z: single) :=
z_TexCoord2fColor3fVertex3fSUN_ovr_0(s, t, r, g, b, x, y, z);
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_0(var tc: Vec2f; var c: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(var tc: Vec2f; var c: Vec3f; var v: Vec3f) :=
z_TexCoord2fColor3fVertex3fvSUN_ovr_0(tc, c, v);
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1(var tc: single; var c: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0100(tc: IntPtr; var c: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0010(var tc: single; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0110(tc: IntPtr; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0001(var tc: single; var c: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0101(tc: IntPtr; var c: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0011(var tc: single; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0111(tc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(tc: array of single; c: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor3fVertex3fvSUN_ovr_1(tc[0], c[0], v[0]) else
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0001(tc[0], c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0010(tc[0], IntPtr.Zero, v[0]) else
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0011(tc[0], IntPtr.Zero, IntPtr.Zero) else
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0100(IntPtr.Zero, c[0], v[0]) else
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0101(IntPtr.Zero, c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0110(IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord2fColor3fVertex3fvSUN_ovr_1_anh0111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(var tc: single; var c: single; var v: single) :=
z_TexCoord2fColor3fVertex3fvSUN_ovr_1(tc, c, v);
private static procedure z_TexCoord2fColor3fVertex3fvSUN_ovr_3(tc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(tc: IntPtr; c: IntPtr; v: IntPtr) :=
z_TexCoord2fColor3fVertex3fvSUN_ovr_3(tc, c, v);
private static procedure z_TexCoord2fNormal3fVertex3fSUN_ovr_0(s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fSUN(s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_TexCoord2fNormal3fVertex3fSUN_ovr_0(s, t, nx, ny, nz, x, y, z);
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_0(var tc: Vec2f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(var tc: Vec2f; var n: Vec3f; var v: Vec3f) :=
z_TexCoord2fNormal3fVertex3fvSUN_ovr_0(tc, n, v);
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1(var tc: single; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0100(tc: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0010(var tc: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0110(tc: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0001(var tc: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0101(tc: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0011(var tc: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0111(tc: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(tc: array of single; n: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1(tc[0], n[0], v[0]) else
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0001(tc[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0010(tc[0], IntPtr.Zero, v[0]) else
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0011(tc[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0100(IntPtr.Zero, n[0], v[0]) else
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0101(IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0110(IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1_anh0111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(var tc: single; var n: single; var v: single) :=
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1(tc, n, v);
private static procedure z_TexCoord2fNormal3fVertex3fvSUN_ovr_3(tc: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(tc: IntPtr; n: IntPtr; v: IntPtr) :=
z_TexCoord2fNormal3fVertex3fvSUN_ovr_3(tc, n, v);
private static procedure z_TexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(s: single; t: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fSUN(s: single; t: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_TexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(s, t, r, g, b, a, nx, ny, nz, x, y, z);
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f) :=
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(tc, c, n, v);
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(var tc: single; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01000(tc: IntPtr; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00100(var tc: single; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01100(tc: IntPtr; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00010(var tc: single; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01010(tc: IntPtr; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00110(var tc: single; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01110(tc: IntPtr; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00001(var tc: single; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01001(tc: IntPtr; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00101(var tc: single; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01101(tc: IntPtr; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00011(var tc: single; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01011(tc: IntPtr; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00111(var tc: single; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01111(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(tc: array of single; c: array of single; n: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(tc[0], c[0], n[0], v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00001(tc[0], c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00010(tc[0], c[0], IntPtr.Zero, v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00011(tc[0], c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00100(tc[0], IntPtr.Zero, n[0], v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00101(tc[0], IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00110(tc[0], IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh00111(tc[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) else
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01000(IntPtr.Zero, c[0], n[0], v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01001(IntPtr.Zero, c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01010(IntPtr.Zero, c[0], IntPtr.Zero, v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01011(IntPtr.Zero, c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01100(IntPtr.Zero, IntPtr.Zero, n[0], v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01101(IntPtr.Zero, IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01110(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh01111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(var tc: single; var c: single; var n: single; var v: single) :=
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(tc, c, n, v);
private static procedure z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr) :=
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(tc, c, n, v);
private static procedure z_TexCoord4fColor4fNormal3fVertex4fSUN_ovr_0(s: single; t: single; p: single; q: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fSUN(s: single; t: single; p: single; q: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single; w: single) :=
z_TexCoord4fColor4fNormal3fVertex4fSUN_ovr_0(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_0(var tc: Vec4f; var c: Vec4f; var n: Vec3f; var v: Vec4f);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(var tc: Vec4f; var c: Vec4f; var n: Vec3f; var v: Vec4f) :=
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_0(tc, c, n, v);
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1(var tc: single; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01000(tc: IntPtr; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00100(var tc: single; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01100(tc: IntPtr; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00010(var tc: single; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01010(tc: IntPtr; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00110(var tc: single; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01110(tc: IntPtr; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00001(var tc: single; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01001(tc: IntPtr; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00101(var tc: single; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01101(tc: IntPtr; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00011(var tc: single; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01011(tc: IntPtr; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00111(var tc: single; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01111(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(tc: array of single; c: array of single; n: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1(tc[0], c[0], n[0], v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00001(tc[0], c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00010(tc[0], c[0], IntPtr.Zero, v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00011(tc[0], c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00100(tc[0], IntPtr.Zero, n[0], v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00101(tc[0], IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00110(tc[0], IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh00111(tc[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) else
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01000(IntPtr.Zero, c[0], n[0], v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01001(IntPtr.Zero, c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01010(IntPtr.Zero, c[0], IntPtr.Zero, v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01011(IntPtr.Zero, c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01100(IntPtr.Zero, IntPtr.Zero, n[0], v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01101(IntPtr.Zero, IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01110(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, v[0]) else
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1_anh01111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(var tc: single; var c: single; var n: single; var v: single) :=
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1(tc, c, n, v);
private static procedure z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_3(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fColor4fNormal3fVertex4fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr) :=
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_3(tc, c, n, v);
private static procedure z_ReplacementCodeuiVertex3fSUN_ovr_0(rc: UInt32; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fSUN(rc: UInt32; x: single; y: single; z: single) :=
z_ReplacementCodeuiVertex3fSUN_ovr_0(rc, x, y, z);
private static procedure z_ReplacementCodeuiVertex3fvSUN_ovr_0(var rc: UInt32; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; var v: Vec3f) :=
z_ReplacementCodeuiVertex3fvSUN_ovr_0(rc, v);
private static procedure z_ReplacementCodeuiVertex3fvSUN_ovr_1(var rc: UInt32; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiVertex3fvSUN';
private static procedure z_ReplacementCodeuiVertex3fvSUN_ovr_1_anh001(var rc: UInt32; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; v: array of single) :=
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiVertex3fvSUN_ovr_1(rc, v[0]) else
z_ReplacementCodeuiVertex3fvSUN_ovr_1_anh001(rc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; var v: single) :=
z_ReplacementCodeuiVertex3fvSUN_ovr_1(rc, v);
private static procedure z_ReplacementCodeuiVertex3fvSUN_ovr_3(rc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(rc: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiVertex3fvSUN_ovr_3(rc, v);
private static procedure z_ReplacementCodeuiColor4ubVertex3fSUN_ovr_0(rc: UInt32; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fSUN(rc: UInt32; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single) :=
z_ReplacementCodeuiColor4ubVertex3fSUN_ovr_0(rc, r, g, b, a, x, y, z);
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_0(var rc: UInt32; var c: Vec4ub; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; var c: Vec4ub; var v: Vec3f) :=
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_0(rc, c, v);
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1(var rc: UInt32; var c: Byte; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0010(var rc: UInt32; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0001(var rc: UInt32; var c: Byte; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0011(var rc: UInt32; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; c: array of Byte; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1(rc, c[0], v[0]) else
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0001(rc, c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0010(rc, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1_anh0011(rc, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; var c: Byte; var v: single) :=
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1(rc, c, v);
private static procedure z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_3(rc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4ubVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(rc: IntPtr; c: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_3(rc, c, v);
private static procedure z_ReplacementCodeuiColor3fVertex3fSUN_ovr_0(rc: UInt32; r: single; g: single; b: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fSUN(rc: UInt32; r: single; g: single; b: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiColor3fVertex3fSUN_ovr_0(rc, r, g, b, x, y, z);
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_0(var rc: UInt32; var c: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; var c: Vec3f; var v: Vec3f) :=
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_0(rc, c, v);
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1(var rc: UInt32; var c: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0010(var rc: UInt32; c: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0001(var rc: UInt32; var c: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0011(var rc: UInt32; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; c: array of single; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1(rc, c[0], v[0]) else
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0001(rc, c[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0010(rc, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1_anh0011(rc, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; var c: single; var v: single) :=
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1(rc, c, v);
private static procedure z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_3(rc: IntPtr; c: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(rc: IntPtr; c: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_3(rc, c, v);
private static procedure z_ReplacementCodeuiNormal3fVertex3fSUN_ovr_0(rc: UInt32; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fSUN(rc: UInt32; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiNormal3fVertex3fSUN_ovr_0(rc, nx, ny, nz, x, y, z);
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_0(var rc: UInt32; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; var n: Vec3f; var v: Vec3f) :=
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_0(rc, n, v);
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1(var rc: UInt32; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0010(var rc: UInt32; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0001(var rc: UInt32; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0011(var rc: UInt32; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; n: array of single; v: array of single) :=
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1(rc, n[0], v[0]) else
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0001(rc, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0010(rc, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1_anh0011(rc, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; var n: single; var v: single) :=
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1(rc, n, v);
private static procedure z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_3(rc: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(rc: IntPtr; n: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_3(rc, n, v);
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_ovr_0(rc: UInt32; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: UInt32; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_ovr_0(rc, r, g, b, a, nx, ny, nz, x, y, z);
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_0(var rc: UInt32; var c: Vec4f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; var c: Vec4f; var n: Vec3f; var v: Vec3f) :=
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_0(rc, c, n, v);
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1(var rc: UInt32; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00100(var rc: UInt32; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00010(var rc: UInt32; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00110(var rc: UInt32; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00001(var rc: UInt32; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00101(var rc: UInt32; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00011(var rc: UInt32; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00111(var rc: UInt32; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; c: array of single; n: array of single; v: array of single) :=
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1(rc, c[0], n[0], v[0]) else
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00001(rc, c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00010(rc, c[0], IntPtr.Zero, v[0]) else
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00011(rc, c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00100(rc, IntPtr.Zero, n[0], v[0]) else
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00101(rc, IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00110(rc, IntPtr.Zero, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1_anh00111(rc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; var c: single; var n: single; var v: single) :=
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1(rc, c, n, v);
private static procedure z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_3(rc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_3(rc, c, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fSUN_ovr_0(rc: UInt32; s: single; t: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fSUN(rc: UInt32; s: single; t: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiTexCoord2fVertex3fSUN_ovr_0(rc, s, t, x, y, z);
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_0(var rc: UInt32; var tc: Vec2f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var v: Vec3f) :=
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_0(rc, tc, v);
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1(var rc: UInt32; var tc: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0010(var rc: UInt32; tc: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0001(var rc: UInt32; var tc: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0011(var rc: UInt32; tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; tc: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1(rc, tc[0], v[0]) else
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0001(rc, tc[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0010(rc, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1_anh0011(rc, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; var tc: single; var v: single) :=
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1(rc, tc, v);
private static procedure z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_3(rc: IntPtr; tc: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(rc: IntPtr; tc: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_3(rc, tc, v);
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_ovr_0(rc: UInt32; s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: UInt32; s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_ovr_0(rc, s, t, nx, ny, nz, x, y, z);
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_0(var rc: UInt32; var tc: Vec2f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var n: Vec3f; var v: Vec3f) :=
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_0(rc, tc, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1(var rc: UInt32; var tc: single; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00100(var rc: UInt32; tc: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00010(var rc: UInt32; var tc: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00110(var rc: UInt32; tc: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00001(var rc: UInt32; var tc: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00101(var rc: UInt32; tc: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00011(var rc: UInt32; var tc: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00111(var rc: UInt32; tc: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; tc: array of single; n: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1(rc, tc[0], n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00001(rc, tc[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00010(rc, tc[0], IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00011(rc, tc[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00100(rc, IntPtr.Zero, n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00101(rc, IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00110(rc, IntPtr.Zero, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1_anh00111(rc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; var tc: single; var n: single; var v: single) :=
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1(rc, tc, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_3(rc: IntPtr; tc: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: IntPtr; tc: IntPtr; n: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_3(rc, tc, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(rc: UInt32; s: single; t: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: UInt32; s: single; t: single; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single) :=
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(var rc: UInt32; var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f) :=
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(rc, tc, c, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(var rc: UInt32; var tc: single; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001000(var rc: UInt32; tc: IntPtr; var c: single; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000100(var rc: UInt32; var tc: single; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001100(var rc: UInt32; tc: IntPtr; c: IntPtr; var n: single; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000010(var rc: UInt32; var tc: single; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001010(var rc: UInt32; tc: IntPtr; var c: single; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000110(var rc: UInt32; var tc: single; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001110(var rc: UInt32; tc: IntPtr; c: IntPtr; n: IntPtr; var v: single);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000001(var rc: UInt32; var tc: single; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001001(var rc: UInt32; tc: IntPtr; var c: single; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000101(var rc: UInt32; var tc: single; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001101(var rc: UInt32; tc: IntPtr; c: IntPtr; var n: single; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000011(var rc: UInt32; var tc: single; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001011(var rc: UInt32; tc: IntPtr; var c: single; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000111(var rc: UInt32; var tc: single; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001111(var rc: UInt32; tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(var rc: UInt32; tc: array of single; c: array of single; n: array of single; v: array of single) :=
if (tc<>nil) and (tc.Length<>0) then
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(rc, tc[0], c[0], n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000001(rc, tc[0], c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000010(rc, tc[0], c[0], IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000011(rc, tc[0], c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000100(rc, tc[0], IntPtr.Zero, n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000101(rc, tc[0], IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000110(rc, tc[0], IntPtr.Zero, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh000111(rc, tc[0], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) else
if (c<>nil) and (c.Length<>0) then
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001000(rc, IntPtr.Zero, c[0], n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001001(rc, IntPtr.Zero, c[0], n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001010(rc, IntPtr.Zero, c[0], IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001011(rc, IntPtr.Zero, c[0], IntPtr.Zero, IntPtr.Zero) else
if (n<>nil) and (n.Length<>0) then
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001100(rc, IntPtr.Zero, IntPtr.Zero, n[0], v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001101(rc, IntPtr.Zero, IntPtr.Zero, n[0], IntPtr.Zero) else
if (v<>nil) and (v.Length<>0) then
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001110(rc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, v[0]) else
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1_anh001111(rc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(var rc: UInt32; var tc: single; var c: single; var n: single; var v: single) :=
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(rc, tc, c, n, v);
private static procedure z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(rc: IntPtr; tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
external 'opengl32.dll' name 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: IntPtr; tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr) :=
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(rc, tc, c, n, v);
end;
[PCUNotRestore]
wglStereoControl3DL = static class
private static function z_SetStereoEmitterState3DL_ovr_0(hDC: GDI_DC; uState: UInt32): UInt32;
external 'opengl32.dll' name 'wglSetStereoEmitterState3DL';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetStereoEmitterState3DL(hDC: GDI_DC; uState: UInt32): UInt32 :=
z_SetStereoEmitterState3DL_ovr_0(hDC, uState);
end;
[PCUNotRestore]
wglGpuAssociationAMD = static class
private static function z_GetGPUIDsAMD_ovr_0(maxCount: UInt32; var ids: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
private static function z_GetGPUIDsAMD_ovr_0_anh001(maxCount: UInt32; ids: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; ids: array of UInt32): UInt32 :=
if (ids<>nil) and (ids.Length<>0) then
z_GetGPUIDsAMD_ovr_0(maxCount, ids[0]) else
z_GetGPUIDsAMD_ovr_0_anh001(maxCount, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; var ids: UInt32): UInt32 :=
z_GetGPUIDsAMD_ovr_0(maxCount, ids);
private static function z_GetGPUIDsAMD_ovr_2(maxCount: UInt32; ids: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; ids: IntPtr): UInt32 :=
z_GetGPUIDsAMD_ovr_2(maxCount, ids);
private static function z_GetGPUInfoAMD_ovr_0(id: UInt32; &property: Int32; dataType: DummyEnum; size: UInt32; data: IntPtr): Int32;
external 'opengl32.dll' name 'wglGetGPUInfoAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUInfoAMD(id: UInt32; &property: Int32; dataType: DummyEnum; size: UInt32; data: IntPtr): Int32 :=
z_GetGPUInfoAMD_ovr_0(id, &property, dataType, size, data);
private static function z_GetContextGPUIDAMD_ovr_0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglGetContextGPUIDAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextGPUIDAMD(hglrc: GLContext): UInt32 :=
z_GetContextGPUIDAMD_ovr_0(hglrc);
private static function z_CreateAssociatedContextAMD_ovr_0(id: UInt32): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAMD(id: UInt32): GLContext :=
z_CreateAssociatedContextAMD_ovr_0(id);
private static function z_CreateAssociatedContextAttribsAMD_ovr_0(id: UInt32; hShareContext: GLContext; var attribList: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
private static function z_CreateAssociatedContextAttribsAMD_ovr_0_anh0001(id: UInt32; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; attribList: array of Int32): GLContext :=
if (attribList<>nil) and (attribList.Length<>0) then
z_CreateAssociatedContextAttribsAMD_ovr_0(id, hShareContext, attribList[0]) else
z_CreateAssociatedContextAttribsAMD_ovr_0_anh0001(id, hShareContext, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; var attribList: Int32): GLContext :=
z_CreateAssociatedContextAttribsAMD_ovr_0(id, hShareContext, attribList);
private static function z_CreateAssociatedContextAttribsAMD_ovr_2(id: UInt32; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; attribList: IntPtr): GLContext :=
z_CreateAssociatedContextAttribsAMD_ovr_2(id, hShareContext, attribList);
private static function z_DeleteAssociatedContextAMD_ovr_0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglDeleteAssociatedContextAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteAssociatedContextAMD(hglrc: GLContext): UInt32 :=
z_DeleteAssociatedContextAMD_ovr_0(hglrc);
private static function z_MakeAssociatedContextCurrentAMD_ovr_0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeAssociatedContextCurrentAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeAssociatedContextCurrentAMD(hglrc: GLContext): UInt32 :=
z_MakeAssociatedContextCurrentAMD_ovr_0(hglrc);
private static function z_GetCurrentAssociatedContextAMD_ovr_0: GLContext;
external 'opengl32.dll' name 'wglGetCurrentAssociatedContextAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentAssociatedContextAMD: GLContext :=
z_GetCurrentAssociatedContextAMD_ovr_0;
private static procedure z_BlitContextFramebufferAMD_ovr_0(dstCtx: GLContext; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: DummyFlags; filter: DummyEnum);
external 'opengl32.dll' name 'wglBlitContextFramebufferAMD';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure BlitContextFramebufferAMD(dstCtx: GLContext; srcX0: Int32; srcY0: Int32; srcX1: Int32; srcY1: Int32; dstX0: Int32; dstY0: Int32; dstX1: Int32; dstY1: Int32; mask: DummyFlags; filter: DummyEnum) :=
z_BlitContextFramebufferAMD_ovr_0(dstCtx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
[PCUNotRestore]
wglBufferRegionARB = static class
private static function z_CreateBufferRegionARB_ovr_0(hDC: GDI_DC; iLayerPlane: Int32; uType: UInt32): IntPtr;
external 'opengl32.dll' name 'wglCreateBufferRegionARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferRegionARB(hDC: GDI_DC; iLayerPlane: Int32; uType: UInt32): IntPtr :=
z_CreateBufferRegionARB_ovr_0(hDC, iLayerPlane, uType);
private static procedure z_DeleteBufferRegionARB_ovr_0(hRegion: IntPtr);
external 'opengl32.dll' name 'wglDeleteBufferRegionARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure DeleteBufferRegionARB(hRegion: IntPtr) :=
z_DeleteBufferRegionARB_ovr_0(hRegion);
private static function z_SaveBufferRegionARB_ovr_0(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32): UInt32;
external 'opengl32.dll' name 'wglSaveBufferRegionARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SaveBufferRegionARB(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32): UInt32 :=
z_SaveBufferRegionARB_ovr_0(hRegion, x, y, width, height);
private static function z_RestoreBufferRegionARB_ovr_0(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32; xSrc: Int32; ySrc: Int32): UInt32;
external 'opengl32.dll' name 'wglRestoreBufferRegionARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RestoreBufferRegionARB(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32; xSrc: Int32; ySrc: Int32): UInt32 :=
z_RestoreBufferRegionARB_ovr_0(hRegion, x, y, width, height, xSrc, ySrc);
end;
[PCUNotRestore]
wglCreateContextARB = static class
private static function z_CreateContextAttribsARB_ovr_0(hDC: GDI_DC; hShareContext: GLContext; var attribList: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
private static function z_CreateContextAttribsARB_ovr_0_anh0001(hDC: GDI_DC; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; attribList: array of Int32): GLContext :=
if (attribList<>nil) and (attribList.Length<>0) then
z_CreateContextAttribsARB_ovr_0(hDC, hShareContext, attribList[0]) else
z_CreateContextAttribsARB_ovr_0_anh0001(hDC, hShareContext, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; var attribList: Int32): GLContext :=
z_CreateContextAttribsARB_ovr_0(hDC, hShareContext, attribList);
private static function z_CreateContextAttribsARB_ovr_2(hDC: GDI_DC; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; attribList: IntPtr): GLContext :=
z_CreateContextAttribsARB_ovr_2(hDC, hShareContext, attribList);
end;
[PCUNotRestore]
wglExtensionsStringARB = static class
private static function z_GetExtensionsStringARB_ovr_0(hdc: GDI_DC): IntPtr;
external 'opengl32.dll' name 'wglGetExtensionsStringARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionsStringARB(hdc: GDI_DC): string;
begin
var res_str_ptr := z_GetExtensionsStringARB_ovr_0(hdc);
Result := Marshal.PtrToStringAnsi(res_str_ptr);
end;
end;
[PCUNotRestore]
wglMakeCurrentReadARB = static class
private static function z_MakeContextCurrentARB_ovr_0(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeContextCurrentARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeContextCurrentARB(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32 :=
z_MakeContextCurrentARB_ovr_0(hDrawDC, hReadDC, hglrc);
private static function z_GetCurrentReadDCARB_ovr_0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentReadDCARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentReadDCARB: GDI_DC :=
z_GetCurrentReadDCARB_ovr_0;
end;
[PCUNotRestore]
wglPbufferARB = static class
private static function z_CreatePbufferARB_ovr_0(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
private static function z_CreatePbufferARB_ovr_0_anh000001(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: array of Int32): HPBUFFER :=
if (piAttribList<>nil) and (piAttribList.Length<>0) then
z_CreatePbufferARB_ovr_0(hDC, iPixelFormat, iWidth, iHeight, piAttribList[0]) else
z_CreatePbufferARB_ovr_0_anh000001(hDC, iPixelFormat, iWidth, iHeight, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER :=
z_CreatePbufferARB_ovr_0(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function z_CreatePbufferARB_ovr_2(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER :=
z_CreatePbufferARB_ovr_2(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function z_GetPbufferDCARB_ovr_0(_hPbuffer: HPBUFFER): GDI_DC;
external 'opengl32.dll' name 'wglGetPbufferDCARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPbufferDCARB(_hPbuffer: HPBUFFER): GDI_DC :=
z_GetPbufferDCARB_ovr_0(_hPbuffer);
private static function z_ReleasePbufferDCARB_ovr_0(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32;
external 'opengl32.dll' name 'wglReleasePbufferDCARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleasePbufferDCARB(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32 :=
z_ReleasePbufferDCARB_ovr_0(_hPbuffer, hDC);
private static function z_DestroyPbufferARB_ovr_0(_hPbuffer: HPBUFFER): UInt32;
external 'opengl32.dll' name 'wglDestroyPbufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyPbufferARB(_hPbuffer: HPBUFFER): UInt32 :=
z_DestroyPbufferARB_ovr_0(_hPbuffer);
private static function z_QueryPbufferARB_ovr_0(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
private static function z_QueryPbufferARB_ovr_0_anh0001(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_QueryPbufferARB_ovr_0(_hPbuffer, iAttribute, piValue[0]) else
z_QueryPbufferARB_ovr_0_anh0001(_hPbuffer, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_QueryPbufferARB_ovr_0(_hPbuffer, iAttribute, piValue);
private static function z_QueryPbufferARB_ovr_2(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_QueryPbufferARB_ovr_2(_hPbuffer, iAttribute, piValue);
end;
[PCUNotRestore]
wglPixelFormatARB = static class
private static function z_GetPixelFormatAttribivARB_ovr_0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
private static function z_GetPixelFormatAttribivARB_ovr_0_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
private static function z_GetPixelFormatAttribivARB_ovr_0_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
private static function z_GetPixelFormatAttribivARB_ovr_0_anh0000011(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: array of Int32): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues[0]) else
z_GetPixelFormatAttribivARB_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], IntPtr.Zero) else
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues[0]) else
z_GetPixelFormatAttribivARB_ovr_0_anh0000011(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, IntPtr.Zero);
private static function z_GetPixelFormatAttribivARB_ovr_1_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var piValues: Int32): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues) else
z_GetPixelFormatAttribivARB_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues);
private static function z_GetPixelFormatAttribivARB_ovr_2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
private static function z_GetPixelFormatAttribivARB_ovr_2_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: IntPtr): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues) else
z_GetPixelFormatAttribivARB_ovr_2_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: array of Int32): UInt32 :=
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues[0]) else
z_GetPixelFormatAttribivARB_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32 :=
z_GetPixelFormatAttribivARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribivARB_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribivARB_ovr_6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
private static function z_GetPixelFormatAttribivARB_ovr_6_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: array of Int32): UInt32 :=
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivARB_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues[0]) else
z_GetPixelFormatAttribivARB_ovr_6_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32 :=
z_GetPixelFormatAttribivARB_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribivARB_ovr_8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribivARB_ovr_8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribfvARB_ovr_0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
private static function z_GetPixelFormatAttribfvARB_ovr_0_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
private static function z_GetPixelFormatAttribfvARB_ovr_0_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
private static function z_GetPixelFormatAttribfvARB_ovr_0_anh0000011(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: array of single): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues[0]) else
z_GetPixelFormatAttribfvARB_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], IntPtr.Zero) else
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues[0]) else
z_GetPixelFormatAttribfvARB_ovr_0_anh0000011(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, IntPtr.Zero);
private static function z_GetPixelFormatAttribfvARB_ovr_1_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var pfValues: single): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues) else
z_GetPixelFormatAttribfvARB_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues);
private static function z_GetPixelFormatAttribfvARB_ovr_2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
private static function z_GetPixelFormatAttribfvARB_ovr_2_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: IntPtr): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues) else
z_GetPixelFormatAttribfvARB_ovr_2_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: array of single): UInt32 :=
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues[0]) else
z_GetPixelFormatAttribfvARB_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32 :=
z_GetPixelFormatAttribfvARB_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribfvARB_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_GetPixelFormatAttribfvARB_ovr_6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
private static function z_GetPixelFormatAttribfvARB_ovr_6_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: array of single): UInt32 :=
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvARB_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues[0]) else
z_GetPixelFormatAttribfvARB_ovr_6_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32 :=
z_GetPixelFormatAttribfvARB_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_GetPixelFormatAttribfvARB_ovr_8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribfvARB_ovr_8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_ChoosePixelFormatARB_ovr_0(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0000011(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0001011(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_0_anh0011011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000011(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001011(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010011(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0011011(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_1_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_1_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_2(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_2_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_3_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_3_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_3_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_3_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_3_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_3_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_4_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_4_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_4_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_5_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_5_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_5_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_6(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_6_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_7_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_7_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_7_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_6_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_6_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_8(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_8_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_8_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_8_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_8(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_8_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_8_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_8_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_9_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_9_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_9_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_9_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000011(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010011(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_10_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_10_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_11_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_11_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_12_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_12_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_13_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_14_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_15_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_15_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_16_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_17_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_8(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_8_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_18(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0000011(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_18_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000011(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0010011(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_19_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_19_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_19_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_18_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_18_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_20(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_20_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_20_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_20_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_20(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_20_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_20_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_20_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_21_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_21_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_22_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_23_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_20(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_20_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_24(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_24_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_24_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_24_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_24(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_24_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_24_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_24_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_25_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_24(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_24_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_26(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_26_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatARB_ovr_26(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_26_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000011(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001011(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_6_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_8(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_8_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_2_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_6_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_8(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_18_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_20_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_18_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_24_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_26(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_54(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0000011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_54_anh0001011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000011(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0001011(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_55_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_55_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_55_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_54_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_56(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_56_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_56_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_56_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_56(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_56_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_56_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_56_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_57_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_57_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_58_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_59_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_56(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_56_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_60(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_60_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_60_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_60_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_60(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_60_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_60_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_60_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_61_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_60(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_60_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_62(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_62_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatARB_ovr_62(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatARB_ovr_62_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_56_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_60_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_62(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_72(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_72_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_72_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_72_anh0000011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_72_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_72_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_72_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatARB_ovr_73_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_72_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_74(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_74_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatARB_ovr_74_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_72_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_78(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
private static function z_ChoosePixelFormatARB_ovr_78_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatARB_ovr_78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatARB_ovr_78_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatARB_ovr_78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatARB_ovr_80(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatARB_ovr_80(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
end;
[PCUNotRestore]
wglRenderTextureARB = static class
private static function z_BindTexImageARB_ovr_0(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglBindTexImageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindTexImageARB(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32 :=
z_BindTexImageARB_ovr_0(_hPbuffer, iBuffer);
private static function z_ReleaseTexImageARB_ovr_0(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglReleaseTexImageARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseTexImageARB(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32 :=
z_ReleaseTexImageARB_ovr_0(_hPbuffer, iBuffer);
private static function z_SetPbufferAttribARB_ovr_0(_hPbuffer: HPBUFFER; var piAttribList: Int32): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
private static function z_SetPbufferAttribARB_ovr_0_anh001(_hPbuffer: HPBUFFER; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; piAttribList: array of Int32): UInt32 :=
if (piAttribList<>nil) and (piAttribList.Length<>0) then
z_SetPbufferAttribARB_ovr_0(_hPbuffer, piAttribList[0]) else
z_SetPbufferAttribARB_ovr_0_anh001(_hPbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; var piAttribList: Int32): UInt32 :=
z_SetPbufferAttribARB_ovr_0(_hPbuffer, piAttribList);
private static function z_SetPbufferAttribARB_ovr_2(_hPbuffer: HPBUFFER; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; piAttribList: IntPtr): UInt32 :=
z_SetPbufferAttribARB_ovr_2(_hPbuffer, piAttribList);
end;
[PCUNotRestore]
wglDisplayColorTableEXT = static class
private static function z_CreateDisplayColorTableEXT_ovr_0(id: UInt16): boolean;
external 'opengl32.dll' name 'wglCreateDisplayColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateDisplayColorTableEXT(id: UInt16): boolean :=
z_CreateDisplayColorTableEXT_ovr_0(id);
private static function z_LoadDisplayColorTableEXT_ovr_0(var table: UInt16; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
private static function z_LoadDisplayColorTableEXT_ovr_0_anh010(table: IntPtr; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(table: array of UInt16; length: UInt32): boolean :=
if (table<>nil) and (table.Length<>0) then
z_LoadDisplayColorTableEXT_ovr_0(table[0], length) else
z_LoadDisplayColorTableEXT_ovr_0_anh010(IntPtr.Zero, length);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(var table: UInt16; length: UInt32): boolean :=
z_LoadDisplayColorTableEXT_ovr_0(table, length);
private static function z_LoadDisplayColorTableEXT_ovr_2(table: IntPtr; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(table: IntPtr; length: UInt32): boolean :=
z_LoadDisplayColorTableEXT_ovr_2(table, length);
private static function z_BindDisplayColorTableEXT_ovr_0(id: UInt16): boolean;
external 'opengl32.dll' name 'wglBindDisplayColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindDisplayColorTableEXT(id: UInt16): boolean :=
z_BindDisplayColorTableEXT_ovr_0(id);
private static procedure z_DestroyDisplayColorTableEXT_ovr_0(id: UInt16);
external 'opengl32.dll' name 'wglDestroyDisplayColorTableEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure DestroyDisplayColorTableEXT(id: UInt16) :=
z_DestroyDisplayColorTableEXT_ovr_0(id);
end;
[PCUNotRestore]
wglExtensionsStringEXT = static class
private static function z_GetExtensionsStringEXT_ovr_0: IntPtr;
external 'opengl32.dll' name 'wglGetExtensionsStringEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionsStringEXT: string;
begin
var res_str_ptr := z_GetExtensionsStringEXT_ovr_0;
Result := Marshal.PtrToStringAnsi(res_str_ptr);
end;
end;
[PCUNotRestore]
wglMakeCurrentReadEXT = static class
private static function z_MakeContextCurrentEXT_ovr_0(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeContextCurrentEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeContextCurrentEXT(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32 :=
z_MakeContextCurrentEXT_ovr_0(hDrawDC, hReadDC, hglrc);
private static function z_GetCurrentReadDCEXT_ovr_0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentReadDCEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentReadDCEXT: GDI_DC :=
z_GetCurrentReadDCEXT_ovr_0;
end;
[PCUNotRestore]
wglPbufferEXT = static class
private static function z_CreatePbufferEXT_ovr_0(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
private static function z_CreatePbufferEXT_ovr_0_anh000001(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: array of Int32): HPBUFFER :=
if (piAttribList<>nil) and (piAttribList.Length<>0) then
z_CreatePbufferEXT_ovr_0(hDC, iPixelFormat, iWidth, iHeight, piAttribList[0]) else
z_CreatePbufferEXT_ovr_0_anh000001(hDC, iPixelFormat, iWidth, iHeight, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER :=
z_CreatePbufferEXT_ovr_0(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function z_CreatePbufferEXT_ovr_2(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER :=
z_CreatePbufferEXT_ovr_2(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function z_GetPbufferDCEXT_ovr_0(_hPbuffer: HPBUFFER): GDI_DC;
external 'opengl32.dll' name 'wglGetPbufferDCEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPbufferDCEXT(_hPbuffer: HPBUFFER): GDI_DC :=
z_GetPbufferDCEXT_ovr_0(_hPbuffer);
private static function z_ReleasePbufferDCEXT_ovr_0(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32;
external 'opengl32.dll' name 'wglReleasePbufferDCEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleasePbufferDCEXT(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32 :=
z_ReleasePbufferDCEXT_ovr_0(_hPbuffer, hDC);
private static function z_DestroyPbufferEXT_ovr_0(_hPbuffer: HPBUFFER): UInt32;
external 'opengl32.dll' name 'wglDestroyPbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyPbufferEXT(_hPbuffer: HPBUFFER): UInt32 :=
z_DestroyPbufferEXT_ovr_0(_hPbuffer);
private static function z_QueryPbufferEXT_ovr_0(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
private static function z_QueryPbufferEXT_ovr_0_anh0001(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_QueryPbufferEXT_ovr_0(_hPbuffer, iAttribute, piValue[0]) else
z_QueryPbufferEXT_ovr_0_anh0001(_hPbuffer, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_QueryPbufferEXT_ovr_0(_hPbuffer, iAttribute, piValue);
private static function z_QueryPbufferEXT_ovr_2(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_QueryPbufferEXT_ovr_2(_hPbuffer, iAttribute, piValue);
end;
[PCUNotRestore]
wglPixelFormatEXT = static class
private static function z_GetPixelFormatAttribivEXT_ovr_0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
private static function z_GetPixelFormatAttribivEXT_ovr_0_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
private static function z_GetPixelFormatAttribivEXT_ovr_0_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
private static function z_GetPixelFormatAttribivEXT_ovr_0_anh0000011(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: array of Int32): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues[0]) else
z_GetPixelFormatAttribivEXT_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], IntPtr.Zero) else
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues[0]) else
z_GetPixelFormatAttribivEXT_ovr_0_anh0000011(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, IntPtr.Zero);
private static function z_GetPixelFormatAttribivEXT_ovr_1_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var piValues: Int32): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues) else
z_GetPixelFormatAttribivEXT_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues);
private static function z_GetPixelFormatAttribivEXT_ovr_2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
private static function z_GetPixelFormatAttribivEXT_ovr_2_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: IntPtr): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], piValues) else
z_GetPixelFormatAttribivEXT_ovr_2_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, piValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: array of Int32): UInt32 :=
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues[0]) else
z_GetPixelFormatAttribivEXT_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32 :=
z_GetPixelFormatAttribivEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribivEXT_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribivEXT_ovr_6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
private static function z_GetPixelFormatAttribivEXT_ovr_6_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: array of Int32): UInt32 :=
if (piValues<>nil) and (piValues.Length<>0) then
z_GetPixelFormatAttribivEXT_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues[0]) else
z_GetPixelFormatAttribivEXT_ovr_6_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32 :=
z_GetPixelFormatAttribivEXT_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribivEXT_ovr_8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribivEXT_ovr_8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function z_GetPixelFormatAttribfvEXT_ovr_0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
private static function z_GetPixelFormatAttribfvEXT_ovr_0_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
private static function z_GetPixelFormatAttribfvEXT_ovr_0_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
private static function z_GetPixelFormatAttribfvEXT_ovr_0_anh0000011(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: array of single): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues[0]) else
z_GetPixelFormatAttribfvEXT_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], IntPtr.Zero) else
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues[0]) else
z_GetPixelFormatAttribfvEXT_ovr_0_anh0000011(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, IntPtr.Zero);
private static function z_GetPixelFormatAttribfvEXT_ovr_1_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var pfValues: single): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues) else
z_GetPixelFormatAttribfvEXT_ovr_0_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues);
private static function z_GetPixelFormatAttribfvEXT_ovr_2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
private static function z_GetPixelFormatAttribfvEXT_ovr_2_anh0000010(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: IntPtr): UInt32 :=
if (piAttributes<>nil) and (piAttributes.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes[0], pfValues) else
z_GetPixelFormatAttribfvEXT_ovr_2_anh0000010(hdc, iPixelFormat, iLayerPlane, nAttributes, IntPtr.Zero, pfValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: array of single): UInt32 :=
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues[0]) else
z_GetPixelFormatAttribfvEXT_ovr_0_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32 :=
z_GetPixelFormatAttribfvEXT_ovr_0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribfvEXT_ovr_2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_GetPixelFormatAttribfvEXT_ovr_6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
private static function z_GetPixelFormatAttribfvEXT_ovr_6_anh0000001(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: array of single): UInt32 :=
if (pfValues<>nil) and (pfValues.Length<>0) then
z_GetPixelFormatAttribfvEXT_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues[0]) else
z_GetPixelFormatAttribfvEXT_ovr_6_anh0000001(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32 :=
z_GetPixelFormatAttribfvEXT_ovr_6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_GetPixelFormatAttribfvEXT_ovr_8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32 :=
z_GetPixelFormatAttribfvEXT_ovr_8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function z_ChoosePixelFormatEXT_ovr_0(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0000011(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0001011(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_0_anh0011011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000011(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001011(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010011(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0011011(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_1_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_1_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_2(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0001010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_2_anh0011010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0000010(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0001010(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0010010(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0011010(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_3_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_3_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_3_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_3_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_3_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_3_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_4_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_4_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_4_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_5_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_5_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_5_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_6(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0001001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_6_anh0011001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0000001(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0001001(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0010001(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0011001(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_7_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_7_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_7_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_6_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_6_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_8(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_8_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_8_anh0001000(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_8_anh0011000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_8(hdc, piAttribIList[0], pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_8_anh0001000(hdc, piAttribIList[0], IntPtr.Zero, nMaxFormats, piFormats, nNumFormats) else
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_8_anh0010000(hdc, IntPtr.Zero, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_8_anh0011000(hdc, IntPtr.Zero, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_9_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_9_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_9_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_9_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000011(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010011(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_10_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_10_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_11_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_11_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_12_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_12_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_13_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_14_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_15_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_15_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_16_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_6_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_17_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_8(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_8_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_18(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0000011(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_18_anh0010011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000011(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0010011(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_19_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_19_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_19_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_18_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_18_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_20(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_20_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_20_anh0000010(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_20_anh0010010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_20(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_20_anh0000010(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_20_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_20_anh0010010(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_21_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_21_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_22_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_18_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_23_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_20(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_20_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_24(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_24_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_24_anh0000001(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_24_anh0010001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_24(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_24_anh0000001(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_24_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_24_anh0010001(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_25_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_24(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_24_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_26(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_26_anh0010000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (piAttribIList<>nil) and (piAttribIList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_26(hdc, piAttribIList[0], pfAttribFList, nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_26_anh0010000(hdc, IntPtr.Zero, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000011(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001011(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_6_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_8(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_8_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_0_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_2_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_0_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_6_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_8(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_18_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_20_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_18_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_24_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_26(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_54(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0000011(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_54_anh0001011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000011(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, IntPtr.Zero) else
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0001011(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_55_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_55_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_55_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_54_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_56(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_56_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_56_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_56_anh0001010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_56(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_56_anh0000010(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, IntPtr.Zero, nNumFormats) else
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_56_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_56_anh0001010(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_57_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_57_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_58_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_54_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_59_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_56(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_56_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_60(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_60_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_60_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_60_anh0001001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_60(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_60_anh0000001(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_60_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_60_anh0001001(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_61_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_60(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_60_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_62(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_62_anh0001000(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
if (pfAttribFList<>nil) and (pfAttribFList.Length<>0) then
z_ChoosePixelFormatEXT_ovr_62(hdc, piAttribIList, pfAttribFList[0], nMaxFormats, piFormats, nNumFormats) else
z_ChoosePixelFormatEXT_ovr_62_anh0001000(hdc, piAttribIList, IntPtr.Zero, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_54_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_56_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_54_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_60_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_62(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_72(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_72_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_72_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_72_anh0000011(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: array of UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_72_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], IntPtr.Zero) else
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_72_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_72_anh0000011(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, IntPtr.Zero);
private static function z_ChoosePixelFormatEXT_ovr_73_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_72_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_74(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_74_anh0000010(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 :=
if (piFormats<>nil) and (piFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats[0], nNumFormats) else
z_ChoosePixelFormatEXT_ovr_74_anh0000010(hdc, piAttribIList, pfAttribFList, nMaxFormats, IntPtr.Zero, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_72_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_78(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
private static function z_ChoosePixelFormatEXT_ovr_78_anh0000001(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 :=
if (nNumFormats<>nil) and (nNumFormats.Length<>0) then
z_ChoosePixelFormatEXT_ovr_78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats[0]) else
z_ChoosePixelFormatEXT_ovr_78_anh0000001(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 :=
z_ChoosePixelFormatEXT_ovr_78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function z_ChoosePixelFormatEXT_ovr_80(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 :=
z_ChoosePixelFormatEXT_ovr_80(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
end;
[PCUNotRestore]
wglSwapControlEXT = static class
private static function z_SwapIntervalEXT_ovr_0(interval: Int32): UInt32;
external 'opengl32.dll' name 'wglSwapIntervalEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapIntervalEXT(interval: Int32): UInt32 :=
z_SwapIntervalEXT_ovr_0(interval);
private static function z_GetSwapIntervalEXT_ovr_0: Int32;
external 'opengl32.dll' name 'wglGetSwapIntervalEXT';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSwapIntervalEXT: Int32 :=
z_GetSwapIntervalEXT_ovr_0;
end;
[PCUNotRestore]
wglDigitalVideoControlI3D = static class
private static function z_GetDigitalVideoParametersI3D_ovr_0(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
private static function z_GetDigitalVideoParametersI3D_ovr_0_anh0001(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_GetDigitalVideoParametersI3D_ovr_0(hDC, iAttribute, piValue[0]) else
z_GetDigitalVideoParametersI3D_ovr_0_anh0001(hDC, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_GetDigitalVideoParametersI3D_ovr_0(hDC, iAttribute, piValue);
private static function z_GetDigitalVideoParametersI3D_ovr_2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_GetDigitalVideoParametersI3D_ovr_2(hDC, iAttribute, piValue);
private static function z_SetDigitalVideoParametersI3D_ovr_0(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
private static function z_SetDigitalVideoParametersI3D_ovr_0_anh0001(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_SetDigitalVideoParametersI3D_ovr_0(hDC, iAttribute, piValue[0]) else
z_SetDigitalVideoParametersI3D_ovr_0_anh0001(hDC, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_SetDigitalVideoParametersI3D_ovr_0(hDC, iAttribute, piValue);
private static function z_SetDigitalVideoParametersI3D_ovr_2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_SetDigitalVideoParametersI3D_ovr_2(hDC, iAttribute, piValue);
end;
[PCUNotRestore]
wglGammaI3D = static class
private static function z_GetGammaTableParametersI3D_ovr_0(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
private static function z_GetGammaTableParametersI3D_ovr_0_anh0001(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_GetGammaTableParametersI3D_ovr_0(hDC, iAttribute, piValue[0]) else
z_GetGammaTableParametersI3D_ovr_0_anh0001(hDC, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_GetGammaTableParametersI3D_ovr_0(hDC, iAttribute, piValue);
private static function z_GetGammaTableParametersI3D_ovr_2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_GetGammaTableParametersI3D_ovr_2(hDC, iAttribute, piValue);
private static function z_SetGammaTableParametersI3D_ovr_0(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
private static function z_SetGammaTableParametersI3D_ovr_0_anh0001(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_SetGammaTableParametersI3D_ovr_0(hDC, iAttribute, piValue[0]) else
z_SetGammaTableParametersI3D_ovr_0_anh0001(hDC, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_SetGammaTableParametersI3D_ovr_0(hDC, iAttribute, piValue);
private static function z_SetGammaTableParametersI3D_ovr_2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_SetGammaTableParametersI3D_ovr_2(hDC, iAttribute, piValue);
private static function z_GetGammaTableI3D_ovr_0(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000001(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000011(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_0_anh000111(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen[0], puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed[0], puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000011(hDC, iEntries, puRed[0], IntPtr.Zero, IntPtr.Zero) else
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000101(hDC, iEntries, IntPtr.Zero, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000111(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_GetGammaTableI3D_ovr_1_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_1_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_1_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue) else
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_0_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue);
private static function z_GetGammaTableI3D_ovr_2(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_2_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_2_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_2_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_2(hDC, iEntries, puRed[0], puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_2_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue) else
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_2_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_2_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue);
private static function z_GetGammaTableI3D_ovr_3_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_3_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed[0], puGreen, IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000101(hDC, iEntries, IntPtr.Zero, puGreen, IntPtr.Zero);
private static function z_GetGammaTableI3D_ovr_4_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_GetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_5_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_GetGammaTableI3D_ovr_2(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_GetGammaTableI3D_ovr_2_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_6(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_6_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_6_anh000001(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_6_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_6(hDC, iEntries, puRed[0], puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_6_anh000001(hDC, iEntries, puRed[0], puGreen, IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_6_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_6_anh000101(hDC, iEntries, IntPtr.Zero, puGreen, IntPtr.Zero);
private static function z_GetGammaTableI3D_ovr_7_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_GetGammaTableI3D_ovr_6(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_GetGammaTableI3D_ovr_6_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_8(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_8_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_GetGammaTableI3D_ovr_8(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_GetGammaTableI3D_ovr_8_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen[0], puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000011(hDC, iEntries, puRed, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_2(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_2_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
z_GetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
z_GetGammaTableI3D_ovr_2(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_6(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_6_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
z_GetGammaTableI3D_ovr_6(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
z_GetGammaTableI3D_ovr_8(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_18(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_18_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_18_anh000001(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_18_anh000011(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen[0], puBlue[0]) else
z_GetGammaTableI3D_ovr_18_anh000001(hDC, iEntries, puRed, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_18_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue[0]) else
z_GetGammaTableI3D_ovr_18_anh000011(hDC, iEntries, puRed, IntPtr.Zero, IntPtr.Zero);
private static function z_GetGammaTableI3D_ovr_19_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_18_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
private static function z_GetGammaTableI3D_ovr_20(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_20_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_GetGammaTableI3D_ovr_20(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_GetGammaTableI3D_ovr_20_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_18_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
z_GetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
z_GetGammaTableI3D_ovr_20(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_24(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
private static function z_GetGammaTableI3D_ovr_24_anh000001(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_GetGammaTableI3D_ovr_24(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_GetGammaTableI3D_ovr_24_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
z_GetGammaTableI3D_ovr_24(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_GetGammaTableI3D_ovr_26(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
z_GetGammaTableI3D_ovr_26(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_0(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000001(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000011(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_0_anh000111(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen[0], puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed[0], puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000011(hDC, iEntries, puRed[0], IntPtr.Zero, IntPtr.Zero) else
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000101(hDC, iEntries, IntPtr.Zero, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000111(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_SetGammaTableI3D_ovr_1_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_1_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_1_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue) else
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_0_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue);
private static function z_SetGammaTableI3D_ovr_2(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_2_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_2_anh000010(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_2_anh000110(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_2(hDC, iEntries, puRed[0], puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_2_anh000010(hDC, iEntries, puRed[0], IntPtr.Zero, puBlue) else
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_2_anh000100(hDC, iEntries, IntPtr.Zero, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_2_anh000110(hDC, iEntries, IntPtr.Zero, IntPtr.Zero, puBlue);
private static function z_SetGammaTableI3D_ovr_3_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_3_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed[0], puGreen, IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000101(hDC, iEntries, IntPtr.Zero, puGreen, IntPtr.Zero);
private static function z_SetGammaTableI3D_ovr_4_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_SetGammaTableI3D_ovr_0_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_5_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_SetGammaTableI3D_ovr_2(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_SetGammaTableI3D_ovr_2_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_6(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_6_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_6_anh000001(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_6_anh000101(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_6(hDC, iEntries, puRed[0], puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_6_anh000001(hDC, iEntries, puRed[0], puGreen, IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_6_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_6_anh000101(hDC, iEntries, IntPtr.Zero, puGreen, IntPtr.Zero);
private static function z_SetGammaTableI3D_ovr_7_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_SetGammaTableI3D_ovr_6(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_SetGammaTableI3D_ovr_6_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_8(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_8_anh000100(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
if (puRed<>nil) and (puRed.Length<>0) then
z_SetGammaTableI3D_ovr_8(hDC, iEntries, puRed[0], puGreen, puBlue) else
z_SetGammaTableI3D_ovr_8_anh000100(hDC, iEntries, IntPtr.Zero, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen[0], puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000011(hDC, iEntries, puRed, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_0_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_2(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_2_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_0_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
z_SetGammaTableI3D_ovr_0(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
z_SetGammaTableI3D_ovr_2(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_6(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_6_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
z_SetGammaTableI3D_ovr_6(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
z_SetGammaTableI3D_ovr_8(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_18(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_18_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_18_anh000001(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_18_anh000011(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen[0], puBlue[0]) else
z_SetGammaTableI3D_ovr_18_anh000001(hDC, iEntries, puRed, puGreen[0], IntPtr.Zero) else
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_18_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue[0]) else
z_SetGammaTableI3D_ovr_18_anh000011(hDC, iEntries, puRed, IntPtr.Zero, IntPtr.Zero);
private static function z_SetGammaTableI3D_ovr_19_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; var puBlue: UInt16): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_18_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
private static function z_SetGammaTableI3D_ovr_20(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_20_anh000010(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: IntPtr): UInt32 :=
if (puGreen<>nil) and (puGreen.Length<>0) then
z_SetGammaTableI3D_ovr_20(hDC, iEntries, puRed, puGreen[0], puBlue) else
z_SetGammaTableI3D_ovr_20_anh000010(hDC, iEntries, puRed, IntPtr.Zero, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_18_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32 :=
z_SetGammaTableI3D_ovr_18(hDC, iEntries, puRed, puGreen, puBlue);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32 :=
z_SetGammaTableI3D_ovr_20(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_24(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
private static function z_SetGammaTableI3D_ovr_24_anh000001(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: array of UInt16): UInt32 :=
if (puBlue<>nil) and (puBlue.Length<>0) then
z_SetGammaTableI3D_ovr_24(hDC, iEntries, puRed, puGreen, puBlue[0]) else
z_SetGammaTableI3D_ovr_24_anh000001(hDC, iEntries, puRed, puGreen, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32 :=
z_SetGammaTableI3D_ovr_24(hDC, iEntries, puRed, puGreen, puBlue);
private static function z_SetGammaTableI3D_ovr_26(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32 :=
z_SetGammaTableI3D_ovr_26(hDC, iEntries, puRed, puGreen, puBlue);
end;
[PCUNotRestore]
wglGenlockI3D = static class
private static function z_EnableGenlockI3D_ovr_0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglEnableGenlockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnableGenlockI3D(hDC: GDI_DC): UInt32 :=
z_EnableGenlockI3D_ovr_0(hDC);
private static function z_DisableGenlockI3D_ovr_0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglDisableGenlockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DisableGenlockI3D(hDC: GDI_DC): UInt32 :=
z_DisableGenlockI3D_ovr_0(hDC);
private static function z_IsEnabledGenlockI3D_ovr_0(hDC: GDI_DC; var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
private static function z_IsEnabledGenlockI3D_ovr_0_anh001(hDC: GDI_DC; pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; pFlag: array of UInt32): UInt32 :=
if (pFlag<>nil) and (pFlag.Length<>0) then
z_IsEnabledGenlockI3D_ovr_0(hDC, pFlag[0]) else
z_IsEnabledGenlockI3D_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; var pFlag: UInt32): UInt32 :=
z_IsEnabledGenlockI3D_ovr_0(hDC, pFlag);
private static function z_IsEnabledGenlockI3D_ovr_2(hDC: GDI_DC; pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; pFlag: IntPtr): UInt32 :=
z_IsEnabledGenlockI3D_ovr_2(hDC, pFlag);
private static function z_GenlockSourceI3D_ovr_0(hDC: GDI_DC; uSource: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceI3D(hDC: GDI_DC; uSource: UInt32): UInt32 :=
z_GenlockSourceI3D_ovr_0(hDC, uSource);
private static function z_GetGenlockSourceI3D_ovr_0(hDC: GDI_DC; var uSource: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
private static function z_GetGenlockSourceI3D_ovr_0_anh001(hDC: GDI_DC; uSource: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; uSource: array of UInt32): UInt32 :=
if (uSource<>nil) and (uSource.Length<>0) then
z_GetGenlockSourceI3D_ovr_0(hDC, uSource[0]) else
z_GetGenlockSourceI3D_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; var uSource: UInt32): UInt32 :=
z_GetGenlockSourceI3D_ovr_0(hDC, uSource);
private static function z_GetGenlockSourceI3D_ovr_2(hDC: GDI_DC; uSource: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; uSource: IntPtr): UInt32 :=
z_GetGenlockSourceI3D_ovr_2(hDC, uSource);
private static function z_GenlockSourceEdgeI3D_ovr_0(hDC: GDI_DC; uEdge: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceEdgeI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: UInt32): UInt32 :=
z_GenlockSourceEdgeI3D_ovr_0(hDC, uEdge);
private static function z_GetGenlockSourceEdgeI3D_ovr_0(hDC: GDI_DC; var uEdge: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
private static function z_GetGenlockSourceEdgeI3D_ovr_0_anh001(hDC: GDI_DC; uEdge: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: array of UInt32): UInt32 :=
if (uEdge<>nil) and (uEdge.Length<>0) then
z_GetGenlockSourceEdgeI3D_ovr_0(hDC, uEdge[0]) else
z_GetGenlockSourceEdgeI3D_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; var uEdge: UInt32): UInt32 :=
z_GetGenlockSourceEdgeI3D_ovr_0(hDC, uEdge);
private static function z_GetGenlockSourceEdgeI3D_ovr_2(hDC: GDI_DC; uEdge: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: IntPtr): UInt32 :=
z_GetGenlockSourceEdgeI3D_ovr_2(hDC, uEdge);
private static function z_GenlockSampleRateI3D_ovr_0(hDC: GDI_DC; uRate: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSampleRateI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSampleRateI3D(hDC: GDI_DC; uRate: UInt32): UInt32 :=
z_GenlockSampleRateI3D_ovr_0(hDC, uRate);
private static function z_GetGenlockSampleRateI3D_ovr_0(hDC: GDI_DC; var uRate: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
private static function z_GetGenlockSampleRateI3D_ovr_0_anh001(hDC: GDI_DC; uRate: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; uRate: array of UInt32): UInt32 :=
if (uRate<>nil) and (uRate.Length<>0) then
z_GetGenlockSampleRateI3D_ovr_0(hDC, uRate[0]) else
z_GetGenlockSampleRateI3D_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; var uRate: UInt32): UInt32 :=
z_GetGenlockSampleRateI3D_ovr_0(hDC, uRate);
private static function z_GetGenlockSampleRateI3D_ovr_2(hDC: GDI_DC; uRate: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; uRate: IntPtr): UInt32 :=
z_GetGenlockSampleRateI3D_ovr_2(hDC, uRate);
private static function z_GenlockSourceDelayI3D_ovr_0(hDC: GDI_DC; uDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceDelayI3D(hDC: GDI_DC; uDelay: UInt32): UInt32 :=
z_GenlockSourceDelayI3D_ovr_0(hDC, uDelay);
private static function z_GetGenlockSourceDelayI3D_ovr_0(hDC: GDI_DC; var uDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
private static function z_GetGenlockSourceDelayI3D_ovr_0_anh001(hDC: GDI_DC; uDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; uDelay: array of UInt32): UInt32 :=
if (uDelay<>nil) and (uDelay.Length<>0) then
z_GetGenlockSourceDelayI3D_ovr_0(hDC, uDelay[0]) else
z_GetGenlockSourceDelayI3D_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; var uDelay: UInt32): UInt32 :=
z_GetGenlockSourceDelayI3D_ovr_0(hDC, uDelay);
private static function z_GetGenlockSourceDelayI3D_ovr_2(hDC: GDI_DC; uDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; uDelay: IntPtr): UInt32 :=
z_GetGenlockSourceDelayI3D_ovr_2(hDC, uDelay);
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_0(hDC: GDI_DC; var uMaxLineDelay: UInt32; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0010(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0001(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0011(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; uMaxPixelDelay: array of UInt32): UInt32 :=
if (uMaxLineDelay<>nil) and (uMaxLineDelay.Length<>0) then
if (uMaxPixelDelay<>nil) and (uMaxPixelDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_0(hDC, uMaxLineDelay[0], uMaxPixelDelay[0]) else
z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0001(hDC, uMaxLineDelay[0], IntPtr.Zero) else
if (uMaxPixelDelay<>nil) and (uMaxPixelDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0010(hDC, IntPtr.Zero, uMaxPixelDelay[0]) else
z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0011(hDC, IntPtr.Zero, IntPtr.Zero);
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_1_anh0010(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; var uMaxPixelDelay: UInt32): UInt32 :=
if (uMaxLineDelay<>nil) and (uMaxLineDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_0(hDC, uMaxLineDelay[0], uMaxPixelDelay) else
z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0010(hDC, IntPtr.Zero, uMaxPixelDelay);
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_2(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_2_anh0010(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; uMaxPixelDelay: IntPtr): UInt32 :=
if (uMaxLineDelay<>nil) and (uMaxLineDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_2(hDC, uMaxLineDelay[0], uMaxPixelDelay) else
z_QueryGenlockMaxSourceDelayI3D_ovr_2_anh0010(hDC, IntPtr.Zero, uMaxPixelDelay);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: array of UInt32): UInt32 :=
if (uMaxPixelDelay<>nil) and (uMaxPixelDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_0(hDC, uMaxLineDelay, uMaxPixelDelay[0]) else
z_QueryGenlockMaxSourceDelayI3D_ovr_0_anh0001(hDC, uMaxLineDelay, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; var uMaxPixelDelay: UInt32): UInt32 :=
z_QueryGenlockMaxSourceDelayI3D_ovr_0(hDC, uMaxLineDelay, uMaxPixelDelay);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: IntPtr): UInt32 :=
z_QueryGenlockMaxSourceDelayI3D_ovr_2(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_6(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_6_anh0001(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: array of UInt32): UInt32 :=
if (uMaxPixelDelay<>nil) and (uMaxPixelDelay.Length<>0) then
z_QueryGenlockMaxSourceDelayI3D_ovr_6(hDC, uMaxLineDelay, uMaxPixelDelay[0]) else
z_QueryGenlockMaxSourceDelayI3D_ovr_6_anh0001(hDC, uMaxLineDelay, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32 :=
z_QueryGenlockMaxSourceDelayI3D_ovr_6(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function z_QueryGenlockMaxSourceDelayI3D_ovr_8(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32 :=
z_QueryGenlockMaxSourceDelayI3D_ovr_8(hDC, uMaxLineDelay, uMaxPixelDelay);
end;
[PCUNotRestore]
wglImageBufferI3D = static class
private static function z_CreateImageBufferI3D_ovr_0(hDC: GDI_DC; dwSize: UInt32; uFlags: UInt32): IntPtr;
external 'opengl32.dll' name 'wglCreateImageBufferI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageBufferI3D(hDC: GDI_DC; dwSize: UInt32; uFlags: UInt32): IntPtr :=
z_CreateImageBufferI3D_ovr_0(hDC, dwSize, uFlags);
private static function z_DestroyImageBufferI3D_ovr_0(hDC: GDI_DC; pAddress: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDestroyImageBufferI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyImageBufferI3D(hDC: GDI_DC; pAddress: IntPtr): UInt32 :=
z_DestroyImageBufferI3D_ovr_0(hDC, pAddress);
private static function z_AssociateImageBufferEventsI3D_ovr_0(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh001100(hDC: GDI_DC; pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh000010(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh001010(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh000110(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_0_anh001110(hDC: GDI_DC; pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: array of IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
if (pAddress<>nil) and (pAddress.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent[0], pAddress[0], pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000010(hDC, pEvent[0], pAddress[0], IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh000100(hDC, pEvent[0], IntPtr.Zero, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000110(hDC, pEvent[0], IntPtr.Zero, IntPtr.Zero, count) else
if (pAddress<>nil) and (pAddress.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh001000(hDC, IntPtr.Zero, pAddress[0], pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh001010(hDC, IntPtr.Zero, pAddress[0], IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh001100(hDC, IntPtr.Zero, IntPtr.Zero, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh001110(hDC, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, count);
private static function z_AssociateImageBufferEventsI3D_ovr_1_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_1_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_1_anh001100(hDC: GDI_DC; pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent[0], pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000100(hDC, pEvent[0], IntPtr.Zero, pSize, count) else
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh001000(hDC, IntPtr.Zero, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh001100(hDC, IntPtr.Zero, IntPtr.Zero, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_2(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_2_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_2_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_2_anh001100(hDC: GDI_DC; pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_2(hDC, pEvent[0], pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_2_anh000100(hDC, pEvent[0], IntPtr.Zero, pSize, count) else
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_2_anh001000(hDC, IntPtr.Zero, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_2_anh001100(hDC, IntPtr.Zero, IntPtr.Zero, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_3_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_3_anh001010(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent[0], pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000010(hDC, pEvent[0], pAddress, IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh001000(hDC, IntPtr.Zero, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh001010(hDC, IntPtr.Zero, pAddress, IntPtr.Zero, count);
private static function z_AssociateImageBufferEventsI3D_ovr_4_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent[0], pAddress, pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh001000(hDC, IntPtr.Zero, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_5_anh001000(hDC: GDI_DC; pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_2(hDC, pEvent[0], pAddress, pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_2_anh001000(hDC, IntPtr.Zero, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_6(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_6_anh001000(hDC: GDI_DC; pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_6_anh000010(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_6_anh001010(hDC: GDI_DC; pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_6(hDC, pEvent[0], pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_6_anh000010(hDC, pEvent[0], pAddress, IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_6_anh001000(hDC, IntPtr.Zero, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_6_anh001010(hDC, IntPtr.Zero, pAddress, IntPtr.Zero, count);
private static function z_AssociateImageBufferEventsI3D_ovr_7_anh001000(hDC: GDI_DC; pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_6(hDC, pEvent[0], pAddress, pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_6_anh001000(hDC, IntPtr.Zero, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_8(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_8_anh001000(hDC: GDI_DC; pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 :=
if (pEvent<>nil) and (pEvent.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_8(hDC, pEvent[0], pAddress, pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_8_anh001000(hDC, IntPtr.Zero, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_9_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_9_anh000110(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent, pAddress[0], pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000010(hDC, pEvent, pAddress[0], IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0_anh000100(hDC, pEvent, IntPtr.Zero, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000110(hDC, pEvent, IntPtr.Zero, IntPtr.Zero, count);
private static function z_AssociateImageBufferEventsI3D_ovr_10_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000100(hDC, pEvent, IntPtr.Zero, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_11_anh000100(hDC: GDI_DC; var pEvent: IntPtr; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_2(hDC, pEvent, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_2_anh000100(hDC, pEvent, IntPtr.Zero, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_0_anh000010(hDC, pEvent, pAddress, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_0(hDC, pEvent, pAddress, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_2(hDC, pEvent, pAddress, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_6(hDC, pEvent, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_6_anh000010(hDC, pEvent, pAddress, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_6(hDC, pEvent, pAddress, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_8(hDC, pEvent, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_18(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_18_anh000100(hDC: GDI_DC; pEvent: pointer; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_18_anh000010(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_18_anh000110(hDC: GDI_DC; pEvent: pointer; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_18(hDC, pEvent, pAddress[0], pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_18_anh000010(hDC, pEvent, pAddress[0], IntPtr.Zero, count) else
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_18_anh000100(hDC, pEvent, IntPtr.Zero, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_18_anh000110(hDC, pEvent, IntPtr.Zero, IntPtr.Zero, count);
private static function z_AssociateImageBufferEventsI3D_ovr_19_anh000100(hDC: GDI_DC; pEvent: pointer; pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_18(hDC, pEvent, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_18_anh000100(hDC, pEvent, IntPtr.Zero, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_20(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_20_anh000100(hDC: GDI_DC; pEvent: pointer; pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_20(hDC, pEvent, pAddress[0], pSize, count) else
z_AssociateImageBufferEventsI3D_ovr_20_anh000100(hDC, pEvent, IntPtr.Zero, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_18(hDC, pEvent, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_18_anh000010(hDC, pEvent, pAddress, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_18(hDC, pEvent, pAddress, pSize, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_20(hDC, pEvent, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_24(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
private static function z_AssociateImageBufferEventsI3D_ovr_24_anh000010(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 :=
if (pSize<>nil) and (pSize.Length<>0) then
z_AssociateImageBufferEventsI3D_ovr_24(hDC, pEvent, pAddress, pSize[0], count) else
z_AssociateImageBufferEventsI3D_ovr_24_anh000010(hDC, pEvent, pAddress, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_24(hDC, pEvent, pAddress, pSize, count);
private static function z_AssociateImageBufferEventsI3D_ovr_26(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 :=
z_AssociateImageBufferEventsI3D_ovr_26(hDC, pEvent, pAddress, pSize, count);
private static function z_ReleaseImageBufferEventsI3D_ovr_0(hDC: GDI_DC; var pAddress: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
private static function z_ReleaseImageBufferEventsI3D_ovr_0_anh0010(hDC: GDI_DC; pAddress: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; pAddress: array of IntPtr; count: UInt32): UInt32 :=
if (pAddress<>nil) and (pAddress.Length<>0) then
z_ReleaseImageBufferEventsI3D_ovr_0(hDC, pAddress[0], count) else
z_ReleaseImageBufferEventsI3D_ovr_0_anh0010(hDC, IntPtr.Zero, count);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; var pAddress: IntPtr; count: UInt32): UInt32 :=
z_ReleaseImageBufferEventsI3D_ovr_0(hDC, pAddress, count);
private static function z_ReleaseImageBufferEventsI3D_ovr_2(hDC: GDI_DC; pAddress: pointer; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; pAddress: pointer; count: UInt32): UInt32 :=
z_ReleaseImageBufferEventsI3D_ovr_2(hDC, pAddress, count);
end;
[PCUNotRestore]
wglSwapFrameLockI3D = static class
private static function z_EnableFrameLockI3D_ovr_0: UInt32;
external 'opengl32.dll' name 'wglEnableFrameLockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnableFrameLockI3D: UInt32 :=
z_EnableFrameLockI3D_ovr_0;
private static function z_DisableFrameLockI3D_ovr_0: UInt32;
external 'opengl32.dll' name 'wglDisableFrameLockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DisableFrameLockI3D: UInt32 :=
z_DisableFrameLockI3D_ovr_0;
private static function z_IsEnabledFrameLockI3D_ovr_0(var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
private static function z_IsEnabledFrameLockI3D_ovr_0_anh01(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(pFlag: array of UInt32): UInt32 :=
if (pFlag<>nil) and (pFlag.Length<>0) then
z_IsEnabledFrameLockI3D_ovr_0(pFlag[0]) else
z_IsEnabledFrameLockI3D_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(var pFlag: UInt32): UInt32 :=
z_IsEnabledFrameLockI3D_ovr_0(pFlag);
private static function z_IsEnabledFrameLockI3D_ovr_2(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(pFlag: IntPtr): UInt32 :=
z_IsEnabledFrameLockI3D_ovr_2(pFlag);
private static function z_QueryFrameLockMasterI3D_ovr_0(var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
private static function z_QueryFrameLockMasterI3D_ovr_0_anh01(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(pFlag: array of UInt32): UInt32 :=
if (pFlag<>nil) and (pFlag.Length<>0) then
z_QueryFrameLockMasterI3D_ovr_0(pFlag[0]) else
z_QueryFrameLockMasterI3D_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(var pFlag: UInt32): UInt32 :=
z_QueryFrameLockMasterI3D_ovr_0(pFlag);
private static function z_QueryFrameLockMasterI3D_ovr_2(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(pFlag: IntPtr): UInt32 :=
z_QueryFrameLockMasterI3D_ovr_2(pFlag);
end;
[PCUNotRestore]
wglSwapFrameUsageI3D = static class
private static function z_GetFrameUsageI3D_ovr_0(var pUsage: single): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
private static function z_GetFrameUsageI3D_ovr_0_anh01(pUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(pUsage: array of single): UInt32 :=
if (pUsage<>nil) and (pUsage.Length<>0) then
z_GetFrameUsageI3D_ovr_0(pUsage[0]) else
z_GetFrameUsageI3D_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(var pUsage: single): UInt32 :=
z_GetFrameUsageI3D_ovr_0(pUsage);
private static function z_GetFrameUsageI3D_ovr_2(pUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(pUsage: IntPtr): UInt32 :=
z_GetFrameUsageI3D_ovr_2(pUsage);
private static function z_BeginFrameTrackingI3D_ovr_0: UInt32;
external 'opengl32.dll' name 'wglBeginFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BeginFrameTrackingI3D: UInt32 :=
z_BeginFrameTrackingI3D_ovr_0;
private static function z_EndFrameTrackingI3D_ovr_0: UInt32;
external 'opengl32.dll' name 'wglEndFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EndFrameTrackingI3D: UInt32 :=
z_EndFrameTrackingI3D_ovr_0;
private static function z_QueryFrameTrackingI3D_ovr_0(var pFrameCount: UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0010(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0110(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0001(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0101(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0011(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_0_anh0111(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount[0], pMissedFrames[0], pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0001(pFrameCount[0], pMissedFrames[0], IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0010(pFrameCount[0], IntPtr.Zero, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0011(pFrameCount[0], IntPtr.Zero, IntPtr.Zero) else
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0100(IntPtr.Zero, pMissedFrames[0], pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0101(IntPtr.Zero, pMissedFrames[0], IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0110(IntPtr.Zero, IntPtr.Zero, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0111(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_QueryFrameTrackingI3D_ovr_1_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_1_anh0010(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_1_anh0110(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount[0], pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_0_anh0010(pFrameCount[0], IntPtr.Zero, pLastMissedUsage) else
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0100(IntPtr.Zero, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_0_anh0110(IntPtr.Zero, IntPtr.Zero, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_2(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_2_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_2_anh0010(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_2_anh0110(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_2(pFrameCount[0], pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_2_anh0010(pFrameCount[0], IntPtr.Zero, pLastMissedUsage) else
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_2_anh0100(IntPtr.Zero, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_2_anh0110(IntPtr.Zero, IntPtr.Zero, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_3_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_3_anh0101(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount[0], pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0001(pFrameCount[0], pMissedFrames, IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0101(IntPtr.Zero, pMissedFrames, IntPtr.Zero);
private static function z_QueryFrameTrackingI3D_ovr_4_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount[0], pMissedFrames, pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_0_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_5_anh0100(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
z_QueryFrameTrackingI3D_ovr_2(pFrameCount[0], pMissedFrames, pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_2_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_6(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_6_anh0100(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_6_anh0001(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_6_anh0101(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_6(pFrameCount[0], pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_6_anh0001(pFrameCount[0], pMissedFrames, IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_6_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_6_anh0101(IntPtr.Zero, pMissedFrames, IntPtr.Zero);
private static function z_QueryFrameTrackingI3D_ovr_7_anh0100(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
z_QueryFrameTrackingI3D_ovr_6(pFrameCount[0], pMissedFrames, pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_6_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_8(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_8_anh0100(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 :=
if (pFrameCount<>nil) and (pFrameCount.Length<>0) then
z_QueryFrameTrackingI3D_ovr_8(pFrameCount[0], pMissedFrames, pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_8_anh0100(IntPtr.Zero, pMissedFrames, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount, pMissedFrames[0], pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0001(pFrameCount, pMissedFrames[0], IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0011(pFrameCount, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_0_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_2(pFrameCount, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_2_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_0(pFrameCount, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_0_anh0001(pFrameCount, pMissedFrames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 :=
z_QueryFrameTrackingI3D_ovr_0(pFrameCount, pMissedFrames, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 :=
z_QueryFrameTrackingI3D_ovr_2(pFrameCount, pMissedFrames, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 :=
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_6(pFrameCount, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_6_anh0001(pFrameCount, pMissedFrames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 :=
z_QueryFrameTrackingI3D_ovr_6(pFrameCount, pMissedFrames, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 :=
z_QueryFrameTrackingI3D_ovr_8(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_18(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_18_anh0010(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_18_anh0001(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_18_anh0011(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_18(pFrameCount, pMissedFrames[0], pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_18_anh0001(pFrameCount, pMissedFrames[0], IntPtr.Zero) else
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_18_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_18_anh0011(pFrameCount, IntPtr.Zero, IntPtr.Zero);
private static function z_QueryFrameTrackingI3D_ovr_19_anh0010(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_18(pFrameCount, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_18_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_20(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_20_anh0010(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 :=
if (pMissedFrames<>nil) and (pMissedFrames.Length<>0) then
z_QueryFrameTrackingI3D_ovr_20(pFrameCount, pMissedFrames[0], pLastMissedUsage) else
z_QueryFrameTrackingI3D_ovr_20_anh0010(pFrameCount, IntPtr.Zero, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 :=
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_18(pFrameCount, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_18_anh0001(pFrameCount, pMissedFrames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 :=
z_QueryFrameTrackingI3D_ovr_18(pFrameCount, pMissedFrames, pLastMissedUsage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 :=
z_QueryFrameTrackingI3D_ovr_20(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_24(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
private static function z_QueryFrameTrackingI3D_ovr_24_anh0001(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 :=
if (pLastMissedUsage<>nil) and (pLastMissedUsage.Length<>0) then
z_QueryFrameTrackingI3D_ovr_24(pFrameCount, pMissedFrames, pLastMissedUsage[0]) else
z_QueryFrameTrackingI3D_ovr_24_anh0001(pFrameCount, pMissedFrames, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 :=
z_QueryFrameTrackingI3D_ovr_24(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function z_QueryFrameTrackingI3D_ovr_26(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 :=
z_QueryFrameTrackingI3D_ovr_26(pFrameCount, pMissedFrames, pLastMissedUsage);
end;
[PCUNotRestore]
wglCopyImageNV = static class
private static function z_CopyImageSubDataNV_ovr_0(hSrcRC: GLContext; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; hDstRC: GLContext; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32): UInt32;
external 'opengl32.dll' name 'wglCopyImageSubDataNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CopyImageSubDataNV(hSrcRC: GLContext; srcName: UInt32; srcTarget: DummyEnum; srcLevel: Int32; srcX: Int32; srcY: Int32; srcZ: Int32; hDstRC: GLContext; dstName: UInt32; dstTarget: DummyEnum; dstLevel: Int32; dstX: Int32; dstY: Int32; dstZ: Int32; width: Int32; height: Int32; depth: Int32): UInt32 :=
z_CopyImageSubDataNV_ovr_0(hSrcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, hDstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
end;
[PCUNotRestore]
wglDelayBeforeSwapNV = static class
private static function z_DelayBeforeSwapNV_ovr_0(hDC: GDI_DC; seconds: single): UInt32;
external 'opengl32.dll' name 'wglDelayBeforeSwapNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DelayBeforeSwapNV(hDC: GDI_DC; seconds: single): UInt32 :=
z_DelayBeforeSwapNV_ovr_0(hDC, seconds);
end;
[PCUNotRestore]
wglDXInteropNV = static class
private static function z_DXSetResourceShareHandleNV_ovr_0(dxObject: IntPtr; shareHandle: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXSetResourceShareHandleNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXSetResourceShareHandleNV(dxObject: IntPtr; shareHandle: IntPtr): UInt32 :=
z_DXSetResourceShareHandleNV_ovr_0(dxObject, shareHandle);
private static function z_DXOpenDeviceNV_ovr_0(dxDevice: IntPtr): IntPtr;
external 'opengl32.dll' name 'wglDXOpenDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXOpenDeviceNV(dxDevice: IntPtr): IntPtr :=
z_DXOpenDeviceNV_ovr_0(dxDevice);
private static function z_DXCloseDeviceNV_ovr_0(hDevice: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXCloseDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXCloseDeviceNV(hDevice: IntPtr): UInt32 :=
z_DXCloseDeviceNV_ovr_0(hDevice);
private static function z_DXRegisterObjectNV_ovr_0(hDevice: IntPtr; dxObject: IntPtr; name: UInt32; &type: DummyEnum; access: DummyEnum): IntPtr;
external 'opengl32.dll' name 'wglDXRegisterObjectNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXRegisterObjectNV(hDevice: IntPtr; dxObject: IntPtr; name: UInt32; &type: DummyEnum; access: DummyEnum): IntPtr :=
z_DXRegisterObjectNV_ovr_0(hDevice, dxObject, name, &type, access);
private static function z_DXUnregisterObjectNV_ovr_0(hDevice: IntPtr; hObject: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnregisterObjectNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnregisterObjectNV(hDevice: IntPtr; hObject: IntPtr): UInt32 :=
z_DXUnregisterObjectNV_ovr_0(hDevice, hObject);
private static function z_DXObjectAccessNV_ovr_0(hObject: IntPtr; access: DummyEnum): UInt32;
external 'opengl32.dll' name 'wglDXObjectAccessNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXObjectAccessNV(hObject: IntPtr; access: DummyEnum): UInt32 :=
z_DXObjectAccessNV_ovr_0(hObject, access);
private static function z_DXLockObjectsNV_ovr_0(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
private static function z_DXLockObjectsNV_ovr_0_anh0001(hDevice: IntPtr; count: Int32; hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: array of IntPtr): UInt32 :=
if (hObjects<>nil) and (hObjects.Length<>0) then
z_DXLockObjectsNV_ovr_0(hDevice, count, hObjects[0]) else
z_DXLockObjectsNV_ovr_0_anh0001(hDevice, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32 :=
z_DXLockObjectsNV_ovr_0(hDevice, count, hObjects);
private static function z_DXLockObjectsNV_ovr_2(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32 :=
z_DXLockObjectsNV_ovr_2(hDevice, count, hObjects);
private static function z_DXUnlockObjectsNV_ovr_0(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
private static function z_DXUnlockObjectsNV_ovr_0_anh0001(hDevice: IntPtr; count: Int32; hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: array of IntPtr): UInt32 :=
if (hObjects<>nil) and (hObjects.Length<>0) then
z_DXUnlockObjectsNV_ovr_0(hDevice, count, hObjects[0]) else
z_DXUnlockObjectsNV_ovr_0_anh0001(hDevice, count, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32 :=
z_DXUnlockObjectsNV_ovr_0(hDevice, count, hObjects);
private static function z_DXUnlockObjectsNV_ovr_2(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32 :=
z_DXUnlockObjectsNV_ovr_2(hDevice, count, hObjects);
end;
[PCUNotRestore]
wglGpuAffinityNV = static class
private static function z_EnumGpusNV_ovr_0(iGpuIndex: UInt32; var phGpu: HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
private static function z_EnumGpusNV_ovr_0_anh001(iGpuIndex: UInt32; phGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; phGpu: array of HGPUNV): UInt32 :=
if (phGpu<>nil) and (phGpu.Length<>0) then
z_EnumGpusNV_ovr_0(iGpuIndex, phGpu[0]) else
z_EnumGpusNV_ovr_0_anh001(iGpuIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; var phGpu: HGPUNV): UInt32 :=
z_EnumGpusNV_ovr_0(iGpuIndex, phGpu);
private static function z_EnumGpusNV_ovr_2(iGpuIndex: UInt32; phGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; phGpu: IntPtr): UInt32 :=
z_EnumGpusNV_ovr_2(iGpuIndex, phGpu);
private static function z_EnumGpuDevicesNV_ovr_0(hGpu: HGPUNV; iDeviceIndex: UInt32; lpGpuDevice: PGPU_DEVICE): UInt32;
external 'opengl32.dll' name 'wglEnumGpuDevicesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpuDevicesNV(hGpu: HGPUNV; iDeviceIndex: UInt32; lpGpuDevice: PGPU_DEVICE): UInt32 :=
z_EnumGpuDevicesNV_ovr_0(hGpu, iDeviceIndex, lpGpuDevice);
private static function z_CreateAffinityDCNV_ovr_0(var phGpuList: HGPUNV): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
private static function z_CreateAffinityDCNV_ovr_0_anh01(phGpuList: IntPtr): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(phGpuList: array of HGPUNV): GDI_DC :=
if (phGpuList<>nil) and (phGpuList.Length<>0) then
z_CreateAffinityDCNV_ovr_0(phGpuList[0]) else
z_CreateAffinityDCNV_ovr_0_anh01(IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(var phGpuList: HGPUNV): GDI_DC :=
z_CreateAffinityDCNV_ovr_0(phGpuList);
private static function z_CreateAffinityDCNV_ovr_2(phGpuList: IntPtr): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(phGpuList: IntPtr): GDI_DC :=
z_CreateAffinityDCNV_ovr_2(phGpuList);
private static function z_EnumGpusFromAffinityDCNV_ovr_0(hAffinityDC: GDI_DC; iGpuIndex: UInt32; var hGpu: HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
private static function z_EnumGpusFromAffinityDCNV_ovr_0_anh0001(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: array of HGPUNV): UInt32 :=
if (hGpu<>nil) and (hGpu.Length<>0) then
z_EnumGpusFromAffinityDCNV_ovr_0(hAffinityDC, iGpuIndex, hGpu[0]) else
z_EnumGpusFromAffinityDCNV_ovr_0_anh0001(hAffinityDC, iGpuIndex, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; var hGpu: HGPUNV): UInt32 :=
z_EnumGpusFromAffinityDCNV_ovr_0(hAffinityDC, iGpuIndex, hGpu);
private static function z_EnumGpusFromAffinityDCNV_ovr_2(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: IntPtr): UInt32 :=
z_EnumGpusFromAffinityDCNV_ovr_2(hAffinityDC, iGpuIndex, hGpu);
private static function z_DeleteDCNV_ovr_0(hdc: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglDeleteDCNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteDCNV(hdc: GDI_DC): UInt32 :=
z_DeleteDCNV_ovr_0(hdc);
end;
[PCUNotRestore]
wglPresentVideoNV = static class
private static function z_EnumerateVideoDevicesNV_ovr_0(hDc: GDI_DC; var phDeviceList: HVIDEOOUTPUTDEVICENV): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
private static function z_EnumerateVideoDevicesNV_ovr_0_anh001(hDc: GDI_DC; phDeviceList: IntPtr): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; phDeviceList: array of HVIDEOOUTPUTDEVICENV): Int32 :=
if (phDeviceList<>nil) and (phDeviceList.Length<>0) then
z_EnumerateVideoDevicesNV_ovr_0(hDc, phDeviceList[0]) else
z_EnumerateVideoDevicesNV_ovr_0_anh001(hDc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; var phDeviceList: HVIDEOOUTPUTDEVICENV): Int32 :=
z_EnumerateVideoDevicesNV_ovr_0(hDc, phDeviceList);
private static function z_EnumerateVideoDevicesNV_ovr_2(hDc: GDI_DC; phDeviceList: IntPtr): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; phDeviceList: IntPtr): Int32 :=
z_EnumerateVideoDevicesNV_ovr_2(hDc, phDeviceList);
private static function z_BindVideoDeviceNV_ovr_0(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; var piAttribList: Int32): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
private static function z_BindVideoDeviceNV_ovr_0_anh00001(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: array of Int32): UInt32 :=
if (piAttribList<>nil) and (piAttribList.Length<>0) then
z_BindVideoDeviceNV_ovr_0(hDc, uVideoSlot, hVideoDevice, piAttribList[0]) else
z_BindVideoDeviceNV_ovr_0_anh00001(hDc, uVideoSlot, hVideoDevice, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; var piAttribList: Int32): UInt32 :=
z_BindVideoDeviceNV_ovr_0(hDc, uVideoSlot, hVideoDevice, piAttribList);
private static function z_BindVideoDeviceNV_ovr_2(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: IntPtr): UInt32 :=
z_BindVideoDeviceNV_ovr_2(hDc, uVideoSlot, hVideoDevice, piAttribList);
private static function z_QueryCurrentContextNV_ovr_0(iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
private static function z_QueryCurrentContextNV_ovr_0_anh001(iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_QueryCurrentContextNV_ovr_0(iAttribute, piValue[0]) else
z_QueryCurrentContextNV_ovr_0_anh001(iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; var piValue: Int32): UInt32 :=
z_QueryCurrentContextNV_ovr_0(iAttribute, piValue);
private static function z_QueryCurrentContextNV_ovr_2(iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_QueryCurrentContextNV_ovr_2(iAttribute, piValue);
end;
[PCUNotRestore]
wglSwapGroupNV = static class
private static function z_JoinSwapGroupNV_ovr_0(hDC: GDI_DC; group: UInt32): UInt32;
external 'opengl32.dll' name 'wglJoinSwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function JoinSwapGroupNV(hDC: GDI_DC; group: UInt32): UInt32 :=
z_JoinSwapGroupNV_ovr_0(hDC, group);
private static function z_BindSwapBarrierNV_ovr_0(group: UInt32; barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglBindSwapBarrierNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindSwapBarrierNV(group: UInt32; barrier: UInt32): UInt32 :=
z_BindSwapBarrierNV_ovr_0(group, barrier);
private static function z_QuerySwapGroupNV_ovr_0(hDC: GDI_DC; var group: UInt32; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
private static function z_QuerySwapGroupNV_ovr_0_anh0010(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
private static function z_QuerySwapGroupNV_ovr_0_anh0001(hDC: GDI_DC; var group: UInt32; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
private static function z_QuerySwapGroupNV_ovr_0_anh0011(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; barrier: array of UInt32): UInt32 :=
if (group<>nil) and (group.Length<>0) then
if (barrier<>nil) and (barrier.Length<>0) then
z_QuerySwapGroupNV_ovr_0(hDC, group[0], barrier[0]) else
z_QuerySwapGroupNV_ovr_0_anh0001(hDC, group[0], IntPtr.Zero) else
if (barrier<>nil) and (barrier.Length<>0) then
z_QuerySwapGroupNV_ovr_0_anh0010(hDC, IntPtr.Zero, barrier[0]) else
z_QuerySwapGroupNV_ovr_0_anh0011(hDC, IntPtr.Zero, IntPtr.Zero);
private static function z_QuerySwapGroupNV_ovr_1_anh0010(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; var barrier: UInt32): UInt32 :=
if (group<>nil) and (group.Length<>0) then
z_QuerySwapGroupNV_ovr_0(hDC, group[0], barrier) else
z_QuerySwapGroupNV_ovr_0_anh0010(hDC, IntPtr.Zero, barrier);
private static function z_QuerySwapGroupNV_ovr_2(hDC: GDI_DC; var group: UInt32; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
private static function z_QuerySwapGroupNV_ovr_2_anh0010(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; barrier: IntPtr): UInt32 :=
if (group<>nil) and (group.Length<>0) then
z_QuerySwapGroupNV_ovr_2(hDC, group[0], barrier) else
z_QuerySwapGroupNV_ovr_2_anh0010(hDC, IntPtr.Zero, barrier);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; barrier: array of UInt32): UInt32 :=
if (barrier<>nil) and (barrier.Length<>0) then
z_QuerySwapGroupNV_ovr_0(hDC, group, barrier[0]) else
z_QuerySwapGroupNV_ovr_0_anh0001(hDC, group, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; var barrier: UInt32): UInt32 :=
z_QuerySwapGroupNV_ovr_0(hDC, group, barrier);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; barrier: IntPtr): UInt32 :=
z_QuerySwapGroupNV_ovr_2(hDC, group, barrier);
private static function z_QuerySwapGroupNV_ovr_6(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
private static function z_QuerySwapGroupNV_ovr_6_anh0001(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; barrier: array of UInt32): UInt32 :=
if (barrier<>nil) and (barrier.Length<>0) then
z_QuerySwapGroupNV_ovr_6(hDC, group, barrier[0]) else
z_QuerySwapGroupNV_ovr_6_anh0001(hDC, group, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32 :=
z_QuerySwapGroupNV_ovr_6(hDC, group, barrier);
private static function z_QuerySwapGroupNV_ovr_8(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32 :=
z_QuerySwapGroupNV_ovr_8(hDC, group, barrier);
private static function z_QueryMaxSwapGroupsNV_ovr_0(hDC: GDI_DC; var maxGroups: UInt32; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
private static function z_QueryMaxSwapGroupsNV_ovr_0_anh0010(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
private static function z_QueryMaxSwapGroupsNV_ovr_0_anh0001(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
private static function z_QueryMaxSwapGroupsNV_ovr_0_anh0011(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; maxBarriers: array of UInt32): UInt32 :=
if (maxGroups<>nil) and (maxGroups.Length<>0) then
if (maxBarriers<>nil) and (maxBarriers.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_0(hDC, maxGroups[0], maxBarriers[0]) else
z_QueryMaxSwapGroupsNV_ovr_0_anh0001(hDC, maxGroups[0], IntPtr.Zero) else
if (maxBarriers<>nil) and (maxBarriers.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_0_anh0010(hDC, IntPtr.Zero, maxBarriers[0]) else
z_QueryMaxSwapGroupsNV_ovr_0_anh0011(hDC, IntPtr.Zero, IntPtr.Zero);
private static function z_QueryMaxSwapGroupsNV_ovr_1_anh0010(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; var maxBarriers: UInt32): UInt32 :=
if (maxGroups<>nil) and (maxGroups.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_0(hDC, maxGroups[0], maxBarriers) else
z_QueryMaxSwapGroupsNV_ovr_0_anh0010(hDC, IntPtr.Zero, maxBarriers);
private static function z_QueryMaxSwapGroupsNV_ovr_2(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
private static function z_QueryMaxSwapGroupsNV_ovr_2_anh0010(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; maxBarriers: IntPtr): UInt32 :=
if (maxGroups<>nil) and (maxGroups.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_2(hDC, maxGroups[0], maxBarriers) else
z_QueryMaxSwapGroupsNV_ovr_2_anh0010(hDC, IntPtr.Zero, maxBarriers);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: array of UInt32): UInt32 :=
if (maxBarriers<>nil) and (maxBarriers.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_0(hDC, maxGroups, maxBarriers[0]) else
z_QueryMaxSwapGroupsNV_ovr_0_anh0001(hDC, maxGroups, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; var maxBarriers: UInt32): UInt32 :=
z_QueryMaxSwapGroupsNV_ovr_0(hDC, maxGroups, maxBarriers);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: IntPtr): UInt32 :=
z_QueryMaxSwapGroupsNV_ovr_2(hDC, maxGroups, maxBarriers);
private static function z_QueryMaxSwapGroupsNV_ovr_6(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
private static function z_QueryMaxSwapGroupsNV_ovr_6_anh0001(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: array of UInt32): UInt32 :=
if (maxBarriers<>nil) and (maxBarriers.Length<>0) then
z_QueryMaxSwapGroupsNV_ovr_6(hDC, maxGroups, maxBarriers[0]) else
z_QueryMaxSwapGroupsNV_ovr_6_anh0001(hDC, maxGroups, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32 :=
z_QueryMaxSwapGroupsNV_ovr_6(hDC, maxGroups, maxBarriers);
private static function z_QueryMaxSwapGroupsNV_ovr_8(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32 :=
z_QueryMaxSwapGroupsNV_ovr_8(hDC, maxGroups, maxBarriers);
private static function z_QueryFrameCountNV_ovr_0(hDC: GDI_DC; var count: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
private static function z_QueryFrameCountNV_ovr_0_anh001(hDC: GDI_DC; count: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; count: array of UInt32): UInt32 :=
if (count<>nil) and (count.Length<>0) then
z_QueryFrameCountNV_ovr_0(hDC, count[0]) else
z_QueryFrameCountNV_ovr_0_anh001(hDC, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; var count: UInt32): UInt32 :=
z_QueryFrameCountNV_ovr_0(hDC, count);
private static function z_QueryFrameCountNV_ovr_2(hDC: GDI_DC; count: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; count: IntPtr): UInt32 :=
z_QueryFrameCountNV_ovr_2(hDC, count);
private static function z_ResetFrameCountNV_ovr_0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglResetFrameCountNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ResetFrameCountNV(hDC: GDI_DC): UInt32 :=
z_ResetFrameCountNV_ovr_0(hDC);
end;
[PCUNotRestore]
wglVideoCaptureNV = static class
private static function z_BindVideoCaptureDeviceNV_ovr_0(uVideoSlot: UInt32; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglBindVideoCaptureDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoCaptureDeviceNV(uVideoSlot: UInt32; hDevice: HVIDEOINPUTDEVICENV): UInt32 :=
z_BindVideoCaptureDeviceNV_ovr_0(uVideoSlot, hDevice);
private static function z_EnumerateVideoCaptureDevicesNV_ovr_0(hDc: GDI_DC; var phDeviceList: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
private static function z_EnumerateVideoCaptureDevicesNV_ovr_0_anh001(hDc: GDI_DC; phDeviceList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; phDeviceList: array of HVIDEOINPUTDEVICENV): UInt32 :=
if (phDeviceList<>nil) and (phDeviceList.Length<>0) then
z_EnumerateVideoCaptureDevicesNV_ovr_0(hDc, phDeviceList[0]) else
z_EnumerateVideoCaptureDevicesNV_ovr_0_anh001(hDc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; var phDeviceList: HVIDEOINPUTDEVICENV): UInt32 :=
z_EnumerateVideoCaptureDevicesNV_ovr_0(hDc, phDeviceList);
private static function z_EnumerateVideoCaptureDevicesNV_ovr_2(hDc: GDI_DC; phDeviceList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; phDeviceList: IntPtr): UInt32 :=
z_EnumerateVideoCaptureDevicesNV_ovr_2(hDc, phDeviceList);
private static function z_LockVideoCaptureDeviceNV_ovr_0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglLockVideoCaptureDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LockVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32 :=
z_LockVideoCaptureDeviceNV_ovr_0(hDc, hDevice);
private static function z_QueryVideoCaptureDeviceNV_ovr_0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
private static function z_QueryVideoCaptureDeviceNV_ovr_0_anh00001(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: array of Int32): UInt32 :=
if (piValue<>nil) and (piValue.Length<>0) then
z_QueryVideoCaptureDeviceNV_ovr_0(hDc, hDevice, iAttribute, piValue[0]) else
z_QueryVideoCaptureDeviceNV_ovr_0_anh00001(hDc, hDevice, iAttribute, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; var piValue: Int32): UInt32 :=
z_QueryVideoCaptureDeviceNV_ovr_0(hDc, hDevice, iAttribute, piValue);
private static function z_QueryVideoCaptureDeviceNV_ovr_2(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: IntPtr): UInt32 :=
z_QueryVideoCaptureDeviceNV_ovr_2(hDc, hDevice, iAttribute, piValue);
private static function z_ReleaseVideoCaptureDeviceNV_ovr_0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoCaptureDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32 :=
z_ReleaseVideoCaptureDeviceNV_ovr_0(hDc, hDevice);
end;
[PCUNotRestore]
wglVideoOutputNV = static class
private static function z_GetVideoDeviceNV_ovr_0(hDC: GDI_DC; numDevices: Int32; var hVideoDevice: HPVIDEODEV): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
private static function z_GetVideoDeviceNV_ovr_0_anh0001(hDC: GDI_DC; numDevices: Int32; hVideoDevice: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; hVideoDevice: array of HPVIDEODEV): UInt32 :=
if (hVideoDevice<>nil) and (hVideoDevice.Length<>0) then
z_GetVideoDeviceNV_ovr_0(hDC, numDevices, hVideoDevice[0]) else
z_GetVideoDeviceNV_ovr_0_anh0001(hDC, numDevices, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; var hVideoDevice: HPVIDEODEV): UInt32 :=
z_GetVideoDeviceNV_ovr_0(hDC, numDevices, hVideoDevice);
private static function z_GetVideoDeviceNV_ovr_2(hDC: GDI_DC; numDevices: Int32; hVideoDevice: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; hVideoDevice: IntPtr): UInt32 :=
z_GetVideoDeviceNV_ovr_2(hDC, numDevices, hVideoDevice);
private static function z_ReleaseVideoDeviceNV_ovr_0(hVideoDevice: HPVIDEODEV): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoDeviceNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoDeviceNV(hVideoDevice: HPVIDEODEV): UInt32 :=
z_ReleaseVideoDeviceNV_ovr_0(hVideoDevice);
private static function z_BindVideoImageNV_ovr_0(hVideoDevice: HPVIDEODEV; _hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglBindVideoImageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoImageNV(hVideoDevice: HPVIDEODEV; _hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32 :=
z_BindVideoImageNV_ovr_0(hVideoDevice, _hPbuffer, iVideoBuffer);
private static function z_ReleaseVideoImageNV_ovr_0(_hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoImageNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoImageNV(_hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32 :=
z_ReleaseVideoImageNV_ovr_0(_hPbuffer, iVideoBuffer);
private static function z_SendPbufferToVideoNV_ovr_0(_hPbuffer: HPBUFFER; iBufferType: Int32; var pulCounterPbuffer: UInt64; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
private static function z_SendPbufferToVideoNV_ovr_0_anh00010(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: IntPtr; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: array of UInt64; bBlock: UInt32): UInt32 :=
if (pulCounterPbuffer<>nil) and (pulCounterPbuffer.Length<>0) then
z_SendPbufferToVideoNV_ovr_0(_hPbuffer, iBufferType, pulCounterPbuffer[0], bBlock) else
z_SendPbufferToVideoNV_ovr_0_anh00010(_hPbuffer, iBufferType, IntPtr.Zero, bBlock);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; var pulCounterPbuffer: UInt64; bBlock: UInt32): UInt32 :=
z_SendPbufferToVideoNV_ovr_0(_hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
private static function z_SendPbufferToVideoNV_ovr_2(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: IntPtr; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: IntPtr; bBlock: UInt32): UInt32 :=
z_SendPbufferToVideoNV_ovr_2(_hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
private static function z_GetVideoInfoNV_ovr_0(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
private static function z_GetVideoInfoNV_ovr_0_anh0010(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
private static function z_GetVideoInfoNV_ovr_0_anh0001(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
private static function z_GetVideoInfoNV_ovr_0_anh0011(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; pulCounterOutputVideo: array of UInt64): UInt32 :=
if (pulCounterOutputPbuffer<>nil) and (pulCounterOutputPbuffer.Length<>0) then
if (pulCounterOutputVideo<>nil) and (pulCounterOutputVideo.Length<>0) then
z_GetVideoInfoNV_ovr_0(hpVideoDevice, pulCounterOutputPbuffer[0], pulCounterOutputVideo[0]) else
z_GetVideoInfoNV_ovr_0_anh0001(hpVideoDevice, pulCounterOutputPbuffer[0], IntPtr.Zero) else
if (pulCounterOutputVideo<>nil) and (pulCounterOutputVideo.Length<>0) then
z_GetVideoInfoNV_ovr_0_anh0010(hpVideoDevice, IntPtr.Zero, pulCounterOutputVideo[0]) else
z_GetVideoInfoNV_ovr_0_anh0011(hpVideoDevice, IntPtr.Zero, IntPtr.Zero);
private static function z_GetVideoInfoNV_ovr_1_anh0010(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; var pulCounterOutputVideo: UInt64): UInt32 :=
if (pulCounterOutputPbuffer<>nil) and (pulCounterOutputPbuffer.Length<>0) then
z_GetVideoInfoNV_ovr_0(hpVideoDevice, pulCounterOutputPbuffer[0], pulCounterOutputVideo) else
z_GetVideoInfoNV_ovr_0_anh0010(hpVideoDevice, IntPtr.Zero, pulCounterOutputVideo);
private static function z_GetVideoInfoNV_ovr_2(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
private static function z_GetVideoInfoNV_ovr_2_anh0010(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; pulCounterOutputVideo: IntPtr): UInt32 :=
if (pulCounterOutputPbuffer<>nil) and (pulCounterOutputPbuffer.Length<>0) then
z_GetVideoInfoNV_ovr_2(hpVideoDevice, pulCounterOutputPbuffer[0], pulCounterOutputVideo) else
z_GetVideoInfoNV_ovr_2_anh0010(hpVideoDevice, IntPtr.Zero, pulCounterOutputVideo);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: array of UInt64): UInt32 :=
if (pulCounterOutputVideo<>nil) and (pulCounterOutputVideo.Length<>0) then
z_GetVideoInfoNV_ovr_0(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo[0]) else
z_GetVideoInfoNV_ovr_0_anh0001(hpVideoDevice, pulCounterOutputPbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; var pulCounterOutputVideo: UInt64): UInt32 :=
z_GetVideoInfoNV_ovr_0(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: IntPtr): UInt32 :=
z_GetVideoInfoNV_ovr_2(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function z_GetVideoInfoNV_ovr_6(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
private static function z_GetVideoInfoNV_ovr_6_anh0001(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: array of UInt64): UInt32 :=
if (pulCounterOutputVideo<>nil) and (pulCounterOutputVideo.Length<>0) then
z_GetVideoInfoNV_ovr_6(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo[0]) else
z_GetVideoInfoNV_ovr_6_anh0001(hpVideoDevice, pulCounterOutputPbuffer, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32 :=
z_GetVideoInfoNV_ovr_6(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function z_GetVideoInfoNV_ovr_8(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32 :=
z_GetVideoInfoNV_ovr_8(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
end;
[PCUNotRestore]
wglVertexArrayRangeNV = static class
private static function z_AllocateMemoryNV_ovr_0(size: Int32; readfreq: single; writefreq: single; priority: single): IntPtr;
external 'opengl32.dll' name 'wglAllocateMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AllocateMemoryNV(size: Int32; readfreq: single; writefreq: single; priority: single): IntPtr :=
z_AllocateMemoryNV_ovr_0(size, readfreq, writefreq, priority);
private static procedure z_FreeMemoryNV_ovr_0(pointer: IntPtr);
external 'opengl32.dll' name 'wglFreeMemoryNV';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure FreeMemoryNV(pointer: IntPtr) :=
z_FreeMemoryNV_ovr_0(pointer);
end;
[PCUNotRestore]
wglSyncControlOML = static class
private static function z_GetSyncValuesOML_ovr_0(hdc: GDI_DC; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00010(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00110(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00001(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00101(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00011(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_0_anh00111(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust[0], msc[0], sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00001(hdc, ust[0], msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00010(hdc, ust[0], IntPtr.Zero, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00011(hdc, ust[0], IntPtr.Zero, IntPtr.Zero) else
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00100(hdc, IntPtr.Zero, msc[0], sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00101(hdc, IntPtr.Zero, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00110(hdc, IntPtr.Zero, IntPtr.Zero, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00111(hdc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_GetSyncValuesOML_ovr_1_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_1_anh00010(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_1_anh00110(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust[0], msc[0], sbc) else
z_GetSyncValuesOML_ovr_0_anh00010(hdc, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00100(hdc, IntPtr.Zero, msc[0], sbc) else
z_GetSyncValuesOML_ovr_0_anh00110(hdc, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_GetSyncValuesOML_ovr_2(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_2_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_2_anh00010(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_2_anh00110(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_2(hdc, ust[0], msc[0], sbc) else
z_GetSyncValuesOML_ovr_2_anh00010(hdc, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_2_anh00100(hdc, IntPtr.Zero, msc[0], sbc) else
z_GetSyncValuesOML_ovr_2_anh00110(hdc, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_GetSyncValuesOML_ovr_3_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_3_anh00101(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust[0], msc, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00001(hdc, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00100(hdc, IntPtr.Zero, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00101(hdc, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_GetSyncValuesOML_ovr_4_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust[0], msc, sbc) else
z_GetSyncValuesOML_ovr_0_anh00100(hdc, IntPtr.Zero, msc, sbc);
private static function z_GetSyncValuesOML_ovr_5_anh00100(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_GetSyncValuesOML_ovr_2(hdc, ust[0], msc, sbc) else
z_GetSyncValuesOML_ovr_2_anh00100(hdc, IntPtr.Zero, msc, sbc);
private static function z_GetSyncValuesOML_ovr_6(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_6_anh00100(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_6_anh00001(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_6_anh00101(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_6(hdc, ust[0], msc, sbc[0]) else
z_GetSyncValuesOML_ovr_6_anh00001(hdc, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_6_anh00100(hdc, IntPtr.Zero, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_6_anh00101(hdc, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_GetSyncValuesOML_ovr_7_anh00100(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_GetSyncValuesOML_ovr_6(hdc, ust[0], msc, sbc) else
z_GetSyncValuesOML_ovr_6_anh00100(hdc, IntPtr.Zero, msc, sbc);
private static function z_GetSyncValuesOML_ovr_8(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_8_anh00100(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_GetSyncValuesOML_ovr_8(hdc, ust[0], msc, sbc) else
z_GetSyncValuesOML_ovr_8_anh00100(hdc, IntPtr.Zero, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust, msc[0], sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00001(hdc, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0_anh00010(hdc, ust, IntPtr.Zero, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00011(hdc, ust, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust, msc[0], sbc) else
z_GetSyncValuesOML_ovr_0_anh00010(hdc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_2(hdc, ust, msc[0], sbc) else
z_GetSyncValuesOML_ovr_2_anh00010(hdc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_0(hdc, ust, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_0_anh00001(hdc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32 :=
z_GetSyncValuesOML_ovr_0(hdc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
z_GetSyncValuesOML_ovr_2(hdc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_6(hdc, ust, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_6_anh00001(hdc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
z_GetSyncValuesOML_ovr_6(hdc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_GetSyncValuesOML_ovr_8(hdc, ust, msc, sbc);
private static function z_GetSyncValuesOML_ovr_18(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_18_anh00010(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_18_anh00001(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_18_anh00011(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_18(hdc, ust, msc[0], sbc[0]) else
z_GetSyncValuesOML_ovr_18_anh00001(hdc, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_18_anh00010(hdc, ust, IntPtr.Zero, sbc[0]) else
z_GetSyncValuesOML_ovr_18_anh00011(hdc, ust, IntPtr.Zero, IntPtr.Zero);
private static function z_GetSyncValuesOML_ovr_19_anh00010(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_18(hdc, ust, msc[0], sbc) else
z_GetSyncValuesOML_ovr_18_anh00010(hdc, ust, IntPtr.Zero, sbc);
private static function z_GetSyncValuesOML_ovr_20(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_20_anh00010(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_GetSyncValuesOML_ovr_20(hdc, ust, msc[0], sbc) else
z_GetSyncValuesOML_ovr_20_anh00010(hdc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_18(hdc, ust, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_18_anh00001(hdc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32 :=
z_GetSyncValuesOML_ovr_18(hdc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32 :=
z_GetSyncValuesOML_ovr_20(hdc, ust, msc, sbc);
private static function z_GetSyncValuesOML_ovr_24(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
private static function z_GetSyncValuesOML_ovr_24_anh00001(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_GetSyncValuesOML_ovr_24(hdc, ust, msc, sbc[0]) else
z_GetSyncValuesOML_ovr_24_anh00001(hdc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32 :=
z_GetSyncValuesOML_ovr_24(hdc, ust, msc, sbc);
private static function z_GetSyncValuesOML_ovr_26(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_GetSyncValuesOML_ovr_26(hdc, ust, msc, sbc);
private static function z_GetMscRateOML_ovr_0(hdc: GDI_DC; var numerator: Int32; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
private static function z_GetMscRateOML_ovr_0_anh0010(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
private static function z_GetMscRateOML_ovr_0_anh0001(hdc: GDI_DC; var numerator: Int32; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
private static function z_GetMscRateOML_ovr_0_anh0011(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; denominator: array of Int32): UInt32 :=
if (numerator<>nil) and (numerator.Length<>0) then
if (denominator<>nil) and (denominator.Length<>0) then
z_GetMscRateOML_ovr_0(hdc, numerator[0], denominator[0]) else
z_GetMscRateOML_ovr_0_anh0001(hdc, numerator[0], IntPtr.Zero) else
if (denominator<>nil) and (denominator.Length<>0) then
z_GetMscRateOML_ovr_0_anh0010(hdc, IntPtr.Zero, denominator[0]) else
z_GetMscRateOML_ovr_0_anh0011(hdc, IntPtr.Zero, IntPtr.Zero);
private static function z_GetMscRateOML_ovr_1_anh0010(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; var denominator: Int32): UInt32 :=
if (numerator<>nil) and (numerator.Length<>0) then
z_GetMscRateOML_ovr_0(hdc, numerator[0], denominator) else
z_GetMscRateOML_ovr_0_anh0010(hdc, IntPtr.Zero, denominator);
private static function z_GetMscRateOML_ovr_2(hdc: GDI_DC; var numerator: Int32; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
private static function z_GetMscRateOML_ovr_2_anh0010(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; denominator: IntPtr): UInt32 :=
if (numerator<>nil) and (numerator.Length<>0) then
z_GetMscRateOML_ovr_2(hdc, numerator[0], denominator) else
z_GetMscRateOML_ovr_2_anh0010(hdc, IntPtr.Zero, denominator);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; denominator: array of Int32): UInt32 :=
if (denominator<>nil) and (denominator.Length<>0) then
z_GetMscRateOML_ovr_0(hdc, numerator, denominator[0]) else
z_GetMscRateOML_ovr_0_anh0001(hdc, numerator, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; var denominator: Int32): UInt32 :=
z_GetMscRateOML_ovr_0(hdc, numerator, denominator);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; denominator: IntPtr): UInt32 :=
z_GetMscRateOML_ovr_2(hdc, numerator, denominator);
private static function z_GetMscRateOML_ovr_6(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
private static function z_GetMscRateOML_ovr_6_anh0001(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; denominator: array of Int32): UInt32 :=
if (denominator<>nil) and (denominator.Length<>0) then
z_GetMscRateOML_ovr_6(hdc, numerator, denominator[0]) else
z_GetMscRateOML_ovr_6_anh0001(hdc, numerator, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32 :=
z_GetMscRateOML_ovr_6(hdc, numerator, denominator);
private static function z_GetMscRateOML_ovr_8(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32 :=
z_GetMscRateOML_ovr_8(hdc, numerator, denominator);
private static function z_SwapBuffersMscOML_ovr_0(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64): Int64;
external 'opengl32.dll' name 'wglSwapBuffersMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapBuffersMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64): Int64 :=
z_SwapBuffersMscOML_ovr_0(hdc, target_msc, divisor, remainder);
private static function z_SwapLayerBuffersMscOML_ovr_0(hdc: GDI_DC; fuPlanes: Int32; target_msc: Int64; divisor: Int64; remainder: Int64): Int64;
external 'opengl32.dll' name 'wglSwapLayerBuffersMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapLayerBuffersMscOML(hdc: GDI_DC; fuPlanes: Int32; target_msc: Int64; divisor: Int64; remainder: Int64): Int64 :=
z_SwapLayerBuffersMscOML_ovr_0(hdc, fuPlanes, target_msc, divisor, remainder);
private static function z_WaitForMscOML_ovr_0(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000110(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000001(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000101(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000011(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_0_anh00000111(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust[0], msc[0], sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000001(hdc, target_msc, divisor, remainder, ust[0], msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000010(hdc, target_msc, divisor, remainder, ust[0], IntPtr.Zero, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000011(hdc, target_msc, divisor, remainder, ust[0], IntPtr.Zero, IntPtr.Zero) else
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc[0], sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000101(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000110(hdc, target_msc, divisor, remainder, IntPtr.Zero, IntPtr.Zero, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000111(hdc, target_msc, divisor, remainder, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_WaitForMscOML_ovr_1_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_1_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_1_anh00000110(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust[0], msc[0], sbc) else
z_WaitForMscOML_ovr_0_anh00000010(hdc, target_msc, divisor, remainder, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc[0], sbc) else
z_WaitForMscOML_ovr_0_anh00000110(hdc, target_msc, divisor, remainder, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_WaitForMscOML_ovr_2(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_2_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_2_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_2_anh00000110(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_2(hdc, target_msc, divisor, remainder, ust[0], msc[0], sbc) else
z_WaitForMscOML_ovr_2_anh00000010(hdc, target_msc, divisor, remainder, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_2_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc[0], sbc) else
z_WaitForMscOML_ovr_2_anh00000110(hdc, target_msc, divisor, remainder, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_WaitForMscOML_ovr_3_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_3_anh00000101(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust[0], msc, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000001(hdc, target_msc, divisor, remainder, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000101(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_WaitForMscOML_ovr_4_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust[0], msc, sbc) else
z_WaitForMscOML_ovr_0_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc);
private static function z_WaitForMscOML_ovr_5_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForMscOML_ovr_2(hdc, target_msc, divisor, remainder, ust[0], msc, sbc) else
z_WaitForMscOML_ovr_2_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc);
private static function z_WaitForMscOML_ovr_6(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_6_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_6_anh00000001(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_6_anh00000101(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_6(hdc, target_msc, divisor, remainder, ust[0], msc, sbc[0]) else
z_WaitForMscOML_ovr_6_anh00000001(hdc, target_msc, divisor, remainder, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_6_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc[0]) else
z_WaitForMscOML_ovr_6_anh00000101(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_WaitForMscOML_ovr_7_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForMscOML_ovr_6(hdc, target_msc, divisor, remainder, ust[0], msc, sbc) else
z_WaitForMscOML_ovr_6_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc);
private static function z_WaitForMscOML_ovr_8(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_8_anh00000100(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForMscOML_ovr_8(hdc, target_msc, divisor, remainder, ust[0], msc, sbc) else
z_WaitForMscOML_ovr_8_anh00000100(hdc, target_msc, divisor, remainder, IntPtr.Zero, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust, msc[0], sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000001(hdc, target_msc, divisor, remainder, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000011(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust, msc[0], sbc) else
z_WaitForMscOML_ovr_0_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_2(hdc, target_msc, divisor, remainder, ust, msc[0], sbc) else
z_WaitForMscOML_ovr_2_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust, msc, sbc[0]) else
z_WaitForMscOML_ovr_0_anh00000001(hdc, target_msc, divisor, remainder, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32 :=
z_WaitForMscOML_ovr_0(hdc, target_msc, divisor, remainder, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
z_WaitForMscOML_ovr_2(hdc, target_msc, divisor, remainder, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_6(hdc, target_msc, divisor, remainder, ust, msc, sbc[0]) else
z_WaitForMscOML_ovr_6_anh00000001(hdc, target_msc, divisor, remainder, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
z_WaitForMscOML_ovr_6(hdc, target_msc, divisor, remainder, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_WaitForMscOML_ovr_8(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function z_WaitForMscOML_ovr_18(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_18_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_18_anh00000001(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_18_anh00000011(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_18(hdc, target_msc, divisor, remainder, ust, msc[0], sbc[0]) else
z_WaitForMscOML_ovr_18_anh00000001(hdc, target_msc, divisor, remainder, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_18_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc[0]) else
z_WaitForMscOML_ovr_18_anh00000011(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, IntPtr.Zero);
private static function z_WaitForMscOML_ovr_19_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_18(hdc, target_msc, divisor, remainder, ust, msc[0], sbc) else
z_WaitForMscOML_ovr_18_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc);
private static function z_WaitForMscOML_ovr_20(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_20_anh00000010(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForMscOML_ovr_20(hdc, target_msc, divisor, remainder, ust, msc[0], sbc) else
z_WaitForMscOML_ovr_20_anh00000010(hdc, target_msc, divisor, remainder, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_18(hdc, target_msc, divisor, remainder, ust, msc, sbc[0]) else
z_WaitForMscOML_ovr_18_anh00000001(hdc, target_msc, divisor, remainder, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32 :=
z_WaitForMscOML_ovr_18(hdc, target_msc, divisor, remainder, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32 :=
z_WaitForMscOML_ovr_20(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function z_WaitForMscOML_ovr_24(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
private static function z_WaitForMscOML_ovr_24_anh00000001(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForMscOML_ovr_24(hdc, target_msc, divisor, remainder, ust, msc, sbc[0]) else
z_WaitForMscOML_ovr_24_anh00000001(hdc, target_msc, divisor, remainder, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32 :=
z_WaitForMscOML_ovr_24(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function z_WaitForMscOML_ovr_26(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_WaitForMscOML_ovr_26(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function z_WaitForSbcOML_ovr_0(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000010(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000110(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000001(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000101(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000011(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_0_anh000111(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust[0], msc[0], sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000001(hdc, target_sbc, ust[0], msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000010(hdc, target_sbc, ust[0], IntPtr.Zero, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000011(hdc, target_sbc, ust[0], IntPtr.Zero, IntPtr.Zero) else
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000100(hdc, target_sbc, IntPtr.Zero, msc[0], sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000101(hdc, target_sbc, IntPtr.Zero, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000110(hdc, target_sbc, IntPtr.Zero, IntPtr.Zero, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000111(hdc, target_sbc, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
private static function z_WaitForSbcOML_ovr_1_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_1_anh000010(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_1_anh000110(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust[0], msc[0], sbc) else
z_WaitForSbcOML_ovr_0_anh000010(hdc, target_sbc, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000100(hdc, target_sbc, IntPtr.Zero, msc[0], sbc) else
z_WaitForSbcOML_ovr_0_anh000110(hdc, target_sbc, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_WaitForSbcOML_ovr_2(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_2_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_2_anh000010(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_2_anh000110(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_2(hdc, target_sbc, ust[0], msc[0], sbc) else
z_WaitForSbcOML_ovr_2_anh000010(hdc, target_sbc, ust[0], IntPtr.Zero, sbc) else
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_2_anh000100(hdc, target_sbc, IntPtr.Zero, msc[0], sbc) else
z_WaitForSbcOML_ovr_2_anh000110(hdc, target_sbc, IntPtr.Zero, IntPtr.Zero, sbc);
private static function z_WaitForSbcOML_ovr_3_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_3_anh000101(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust[0], msc, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000001(hdc, target_sbc, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000101(hdc, target_sbc, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_WaitForSbcOML_ovr_4_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust[0], msc, sbc) else
z_WaitForSbcOML_ovr_0_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc);
private static function z_WaitForSbcOML_ovr_5_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForSbcOML_ovr_2(hdc, target_sbc, ust[0], msc, sbc) else
z_WaitForSbcOML_ovr_2_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc);
private static function z_WaitForSbcOML_ovr_6(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_6_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_6_anh000001(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_6_anh000101(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_6(hdc, target_sbc, ust[0], msc, sbc[0]) else
z_WaitForSbcOML_ovr_6_anh000001(hdc, target_sbc, ust[0], msc, IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_6_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc[0]) else
z_WaitForSbcOML_ovr_6_anh000101(hdc, target_sbc, IntPtr.Zero, msc, IntPtr.Zero);
private static function z_WaitForSbcOML_ovr_7_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForSbcOML_ovr_6(hdc, target_sbc, ust[0], msc, sbc) else
z_WaitForSbcOML_ovr_6_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc);
private static function z_WaitForSbcOML_ovr_8(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_8_anh000100(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
if (ust<>nil) and (ust.Length<>0) then
z_WaitForSbcOML_ovr_8(hdc, target_sbc, ust[0], msc, sbc) else
z_WaitForSbcOML_ovr_8_anh000100(hdc, target_sbc, IntPtr.Zero, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust, msc[0], sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000001(hdc, target_sbc, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000011(hdc, target_sbc, ust, IntPtr.Zero, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust, msc[0], sbc) else
z_WaitForSbcOML_ovr_0_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_2(hdc, target_sbc, ust, msc[0], sbc) else
z_WaitForSbcOML_ovr_2_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust, msc, sbc[0]) else
z_WaitForSbcOML_ovr_0_anh000001(hdc, target_sbc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32 :=
z_WaitForSbcOML_ovr_0(hdc, target_sbc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32 :=
z_WaitForSbcOML_ovr_2(hdc, target_sbc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_6(hdc, target_sbc, ust, msc, sbc[0]) else
z_WaitForSbcOML_ovr_6_anh000001(hdc, target_sbc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32 :=
z_WaitForSbcOML_ovr_6(hdc, target_sbc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_WaitForSbcOML_ovr_8(hdc, target_sbc, ust, msc, sbc);
private static function z_WaitForSbcOML_ovr_18(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_18_anh000010(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_18_anh000001(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_18_anh000011(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; sbc: array of Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_18(hdc, target_sbc, ust, msc[0], sbc[0]) else
z_WaitForSbcOML_ovr_18_anh000001(hdc, target_sbc, ust, msc[0], IntPtr.Zero) else
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_18_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc[0]) else
z_WaitForSbcOML_ovr_18_anh000011(hdc, target_sbc, ust, IntPtr.Zero, IntPtr.Zero);
private static function z_WaitForSbcOML_ovr_19_anh000010(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; var sbc: Int64): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_18(hdc, target_sbc, ust, msc[0], sbc) else
z_WaitForSbcOML_ovr_18_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc);
private static function z_WaitForSbcOML_ovr_20(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_20_anh000010(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; sbc: IntPtr): UInt32 :=
if (msc<>nil) and (msc.Length<>0) then
z_WaitForSbcOML_ovr_20(hdc, target_sbc, ust, msc[0], sbc) else
z_WaitForSbcOML_ovr_20_anh000010(hdc, target_sbc, ust, IntPtr.Zero, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_18(hdc, target_sbc, ust, msc, sbc[0]) else
z_WaitForSbcOML_ovr_18_anh000001(hdc, target_sbc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32 :=
z_WaitForSbcOML_ovr_18(hdc, target_sbc, ust, msc, sbc);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32 :=
z_WaitForSbcOML_ovr_20(hdc, target_sbc, ust, msc, sbc);
private static function z_WaitForSbcOML_ovr_24(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
private static function z_WaitForSbcOML_ovr_24_anh000001(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: array of Int64): UInt32 :=
if (sbc<>nil) and (sbc.Length<>0) then
z_WaitForSbcOML_ovr_24(hdc, target_sbc, ust, msc, sbc[0]) else
z_WaitForSbcOML_ovr_24_anh000001(hdc, target_sbc, ust, msc, IntPtr.Zero);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32 :=
z_WaitForSbcOML_ovr_24(hdc, target_sbc, ust, msc, sbc);
private static function z_WaitForSbcOML_ovr_26(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32 :=
z_WaitForSbcOML_ovr_26(hdc, target_sbc, ust, msc, sbc);
end;
{$endregion Extensions}
///Методы для интеграции с gdi
gl_gdi = static class
{$reference System.Windows.Forms.dll}
{$region Misc}
///Создаёт новую поверхность рисования GDI для дескриптора элемента управления
public static function GetControlDC(hwnd: IntPtr): GDI_DC;
external 'user32.dll' name 'GetDC';
{$endregion Misc}
{$region InitControl}
///Создаёт и настраивает поверхность рисования GDI элемента управления WF
///hwnd - дескриптор элемента управления
public static function InitControl(hwnd: IntPtr): GDI_DC;
begin
Result := gl_gdi.GetControlDC(hwnd);
var pfd: GDI_PixelFormatDescriptor;
pfd.nVersion := 1;
pfd.dwFlags :=
PixelFormatFlagsGDI.DRAW_TO_WINDOW or
PixelFormatFlagsGDI.SUPPORT_OPENGL or
PixelFormatFlagsGDI.DOUBLEBUFFER
;
pfd.cColorBits := 24;
pfd.cDepthBits := 16;
if 1 <> gdi.SetPixelFormat(
Result,
gdi.ChoosePixelFormat(Result, pfd),
pfd
) then raise new InvalidOperationException;
end;
///Создаёт и настраивает поверхность рисования GDI элемента управления WF
public static function InitControl(c: System.Windows.Forms.Control) := InitControl(c.Handle);
{$endregion InitControl}
{$region SetupControlRedrawing}
///Добавляет в эвент Form.Load формы (f) обработчик, который:
///1. Создаёт контекст OpenGL на поверхности рисования GDI (hdc)
///2. Запускает перерисовку (RedrawThreadProc)
public static procedure SetupControlRedrawing(f: System.Windows.Forms.Form; hdc: GDI_DC; RedrawThreadProc: procedure(EndFrame: ()->()); vsync_fps: integer := 65);
begin
f.Load += (o,e)->
System.Threading.Thread.Create(()->
begin
var context := wgl.CreateContext(hdc);
if 1 <> wgl.MakeCurrent(hdc, context) then raise new InvalidOperationException('Не удалось применить контекст');
var EndFrame: ()->();
if vsync_fps<=0 then
EndFrame := ()->gdi.SwapBuffers(hdc) else
begin
var LastRedr := DateTime.UtcNow;
var FrameDuration := new TimeSpan(Trunc(TimeSpan.TicksPerSecond/vsync_fps));
var MaxSlowDown := FrameDuration.Ticks*3;
EndFrame := ()->
begin
gdi.SwapBuffers(hdc);
LastRedr := LastRedr+FrameDuration;
var time_left := LastRedr-DateTime.UtcNow;
if time_left.Ticks>0 then
System.Threading.Thread.Sleep(time_left) else
if -time_left.Ticks > MaxSlowDown then
LastRedr := LastRedr.AddTicks(-time_left.Ticks - MaxSlowDown);
end;
end;
RedrawThreadProc(EndFrame);
end).Start();
end;
{$endregion SetupControlRedrawing}
end;
implementation
{$region MtrMlt}
function operator*(m1: Mtr2x2f; m2: Mtr2x2f): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
end;
function operator*(m1: Mtr2x2f; m2: Mtr2x3f): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
end;
function operator*(m1: Mtr2x2f; m2: Mtr2x4f): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
end;
function operator*(m1: Mtr2x2f; m2: Mtr2x2d): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
end;
function operator*(m1: Mtr2x2f; m2: Mtr2x3d): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
end;
function operator*(m1: Mtr2x2f; m2: Mtr2x4d): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x3f): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x2f): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x4f): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x3d): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x2d): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
end;
function operator*(m1: Mtr3x3f; m2: Mtr3x4d): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x4f): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23 + m1.val33*m2.val33;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x2f): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x3f): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x4d): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23 + m1.val33*m2.val33;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x2d): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
end;
function operator*(m1: Mtr4x4f; m2: Mtr4x3d): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x3f): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x2f): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x4f): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x3d): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x2d): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
end;
function operator*(m1: Mtr2x3f; m2: Mtr3x4d): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x2f): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x3f): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x4f): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x2d): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x3d): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
end;
function operator*(m1: Mtr3x2f; m2: Mtr2x4d): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x4f): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x2f): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x3f): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x4d): Mtr2x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x2d): Mtr2x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
end;
function operator*(m1: Mtr2x4f; m2: Mtr4x3d): Mtr2x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x2f): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x3f): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x4f): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x2d): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x3d): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
end;
function operator*(m1: Mtr4x2f; m2: Mtr2x4d): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x4f): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x2f): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x3f): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x4d): Mtr3x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x2d): Mtr3x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
end;
function operator*(m1: Mtr3x4f; m2: Mtr4x3d): Mtr3x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x3f): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x2f): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x4f): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x3d): Mtr4x3f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x2d): Mtr4x2f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
end;
function operator*(m1: Mtr4x3f; m2: Mtr3x4d): Mtr4x4f; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x2f): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x3f): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x4f): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x2d): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x3d): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
end;
function operator*(m1: Mtr2x2d; m2: Mtr2x4d): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x3f): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x2f): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x4f): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x3d): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x2d): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
end;
function operator*(m1: Mtr3x3d; m2: Mtr3x4d): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x4f): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23 + m1.val33*m2.val33;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x2f): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x3f): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x4d): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23 + m1.val33*m2.val33;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x2d): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
end;
function operator*(m1: Mtr4x4d; m2: Mtr4x3d): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20 + m1.val33*m2.val30;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21 + m1.val33*m2.val31;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22 + m1.val33*m2.val32;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x3f): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x2f): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x4f): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x3d): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x2d): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
end;
function operator*(m1: Mtr2x3d; m2: Mtr3x4d): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x2f): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x3f): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x4f): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x2d): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x3d): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
end;
function operator*(m1: Mtr3x2d; m2: Mtr2x4d): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x4f): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x2f): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x3f): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x4d): Mtr2x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x2d): Mtr2x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
end;
function operator*(m1: Mtr2x4d; m2: Mtr4x3d): Mtr2x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x2f): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x3f): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x4f): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x2d): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x3d): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
end;
function operator*(m1: Mtr4x2d; m2: Mtr2x4d): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x4f): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x2f): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x3f): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x4d): Mtr3x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23 + m1.val03*m2.val33;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23 + m1.val13*m2.val33;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23 + m1.val23*m2.val33;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x2d): Mtr3x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
end;
function operator*(m1: Mtr3x4d; m2: Mtr4x3d): Mtr3x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20 + m1.val03*m2.val30;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21 + m1.val03*m2.val31;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22 + m1.val03*m2.val32;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20 + m1.val13*m2.val30;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21 + m1.val13*m2.val31;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22 + m1.val13*m2.val32;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20 + m1.val23*m2.val30;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21 + m1.val23*m2.val31;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22 + m1.val23*m2.val32;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x3f): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x2f): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x4f): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x3d): Mtr4x3d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x2d): Mtr4x2d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
end;
function operator*(m1: Mtr4x3d; m2: Mtr3x4d): Mtr4x4d; extensionmethod;
begin
Result.val00 := m1.val00*m2.val00 + m1.val01*m2.val10 + m1.val02*m2.val20;
Result.val01 := m1.val00*m2.val01 + m1.val01*m2.val11 + m1.val02*m2.val21;
Result.val02 := m1.val00*m2.val02 + m1.val01*m2.val12 + m1.val02*m2.val22;
Result.val03 := m1.val00*m2.val03 + m1.val01*m2.val13 + m1.val02*m2.val23;
Result.val10 := m1.val10*m2.val00 + m1.val11*m2.val10 + m1.val12*m2.val20;
Result.val11 := m1.val10*m2.val01 + m1.val11*m2.val11 + m1.val12*m2.val21;
Result.val12 := m1.val10*m2.val02 + m1.val11*m2.val12 + m1.val12*m2.val22;
Result.val13 := m1.val10*m2.val03 + m1.val11*m2.val13 + m1.val12*m2.val23;
Result.val20 := m1.val20*m2.val00 + m1.val21*m2.val10 + m1.val22*m2.val20;
Result.val21 := m1.val20*m2.val01 + m1.val21*m2.val11 + m1.val22*m2.val21;
Result.val22 := m1.val20*m2.val02 + m1.val21*m2.val12 + m1.val22*m2.val22;
Result.val23 := m1.val20*m2.val03 + m1.val21*m2.val13 + m1.val22*m2.val23;
Result.val30 := m1.val30*m2.val00 + m1.val31*m2.val10 + m1.val32*m2.val20;
Result.val31 := m1.val30*m2.val01 + m1.val31*m2.val11 + m1.val32*m2.val21;
Result.val32 := m1.val30*m2.val02 + m1.val31*m2.val12 + m1.val32*m2.val22;
Result.val33 := m1.val30*m2.val03 + m1.val31*m2.val13 + m1.val32*m2.val23;
end;
{$endregion MtrMlt}
{$region MtrTranspose}
function Transpose(self: Mtr2x2f); extensionmethod :=
new Mtr2x2f(self.val00, self.val10, self.val01, self.val11);
function Transpose(self: Mtr3x3f); extensionmethod :=
new Mtr3x3f(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21, self.val02, self.val12, self.val22);
function Transpose(self: Mtr4x4f); extensionmethod :=
new Mtr4x4f(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31, self.val02, self.val12, self.val22, self.val32, self.val03, self.val13, self.val23, self.val33);
function Transpose(self: Mtr2x3f); extensionmethod :=
new Mtr3x2f(self.val00, self.val10, self.val01, self.val11, self.val02, self.val12);
function Transpose(self: Mtr3x2f); extensionmethod :=
new Mtr2x3f(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21);
function Transpose(self: Mtr2x4f); extensionmethod :=
new Mtr4x2f(self.val00, self.val10, self.val01, self.val11, self.val02, self.val12, self.val03, self.val13);
function Transpose(self: Mtr4x2f); extensionmethod :=
new Mtr2x4f(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31);
function Transpose(self: Mtr3x4f); extensionmethod :=
new Mtr4x3f(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21, self.val02, self.val12, self.val22, self.val03, self.val13, self.val23);
function Transpose(self: Mtr4x3f); extensionmethod :=
new Mtr3x4f(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31, self.val02, self.val12, self.val22, self.val32);
function Transpose(self: Mtr2x2d); extensionmethod :=
new Mtr2x2d(self.val00, self.val10, self.val01, self.val11);
function Transpose(self: Mtr3x3d); extensionmethod :=
new Mtr3x3d(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21, self.val02, self.val12, self.val22);
function Transpose(self: Mtr4x4d); extensionmethod :=
new Mtr4x4d(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31, self.val02, self.val12, self.val22, self.val32, self.val03, self.val13, self.val23, self.val33);
function Transpose(self: Mtr2x3d); extensionmethod :=
new Mtr3x2d(self.val00, self.val10, self.val01, self.val11, self.val02, self.val12);
function Transpose(self: Mtr3x2d); extensionmethod :=
new Mtr2x3d(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21);
function Transpose(self: Mtr2x4d); extensionmethod :=
new Mtr4x2d(self.val00, self.val10, self.val01, self.val11, self.val02, self.val12, self.val03, self.val13);
function Transpose(self: Mtr4x2d); extensionmethod :=
new Mtr2x4d(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31);
function Transpose(self: Mtr3x4d); extensionmethod :=
new Mtr4x3d(self.val00, self.val10, self.val20, self.val01, self.val11, self.val21, self.val02, self.val12, self.val22, self.val03, self.val13, self.val23);
function Transpose(self: Mtr4x3d); extensionmethod :=
new Mtr3x4d(self.val00, self.val10, self.val20, self.val30, self.val01, self.val11, self.val21, self.val31, self.val02, self.val12, self.val22, self.val32);
{$endregion MtrTranspose}
end. |
unit uFinContaCorrenteReconcile;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
uParentDialogFrm, StdCtrls, Buttons, ExtCtrls, Db, ADODB, siComp,
siLangRT;
type
TFinContaCorrenteReconcile = class(TParentDialogFrm)
quContaCorrente: TADOQuery;
quContaCorrenteUltimoSaldoBancario: TFloatField;
quContaCorrenteUltimaReconciliacao: TDateTimeField;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
edtOpenBal: TEdit;
edtCloseBal: TEdit;
lbReconcDate: TLabel;
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure FormShow(Sender: TObject);
procedure edtOpenBalKeyPress(Sender: TObject; var Key: Char);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
sLatRecon : string;
IDConta : Integer;
procedure OpenContaCorrente;
procedure CloseContaCorrente;
public
{ Public declarations }
function Start(var StartBalance, EndBalance : Currency; IDConta:Integer):Boolean;
end;
implementation
uses uDM, uNumericFunctions, uDMGlobal;
{$R *.DFM}
procedure TFinContaCorrenteReconcile.OpenContaCorrente;
begin
with quContaCorrente do
begin
Parameters.ParamByName('IDContaCorrente').Value := IDConta;
Open;
edtOpenBal.Text := FormatFloat('##0.00', quContaCorrenteUltimoSaldoBancario.AsCurrency);
lbReconcDate.Caption := sLatRecon + quContaCorrenteUltimaReconciliacao.AsString;
end;
end;
procedure TFinContaCorrenteReconcile.CloseContaCorrente;
begin
with quContaCorrente do
if Active then
Close;
end;
function TFinContaCorrenteReconcile.Start(var StartBalance, EndBalance : Currency; IDConta:Integer):Boolean;
begin
Self.IDConta := IDConta;
ShowModal;
if (ModalResult=mrOk) then
begin
StartBalance := MyStrToFloat(edtOpenBal.Text);
EndBalance := MyStrToFloat(edtCloseBal.Text);
Result := True;
end;
end;
procedure TFinContaCorrenteReconcile.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
inherited;
CloseContaCorrente;
end;
procedure TFinContaCorrenteReconcile.FormShow(Sender: TObject);
begin
inherited;
OpenContaCorrente;
CloseContaCorrente;
end;
procedure TFinContaCorrenteReconcile.edtOpenBalKeyPress(Sender: TObject;
var Key: Char);
begin
inherited;
Key := ValidateFloat(Key);
end;
procedure TFinContaCorrenteReconcile.FormCreate(Sender: TObject);
begin
inherited;
case DMGlobal.IDLanguage of
LANG_ENGLISH :
begin
sLatRecon := 'This account was last reconciled ';
end;
LANG_PORTUGUESE :
begin
sLatRecon := 'Esta conta foi reconciliada ';
end;
LANG_SPANISH :
begin
sLatRecon := 'Esta coenta foi reconciliada ';
end;
end;
end;
end.
|
unit uDownloadManager;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Layouts, FMX.ListBox, FMX.StdCtrls, FMX.Edit,
FMX.Controls.Presentation, FMX.ListView.Types, FMX.ListView, FMX.EditBox, FMX.SpinBox, uDownloadThread;
type
TFrDownloadManager = class(TForm)
Panel1: TPanel;
EdUrl: TEdit;
BtnGetLinks: TButton;
LbLinks: TListBox;
BtnExplore: TButton;
BtnDownload: TButton;
Panel2: TPanel;
LbDownloads: TListBox;
EdFileName: TEdit;
btnPause: TButton;
btnRemove: TButton;
BtnResume: TButton;
EdDirect: TEdit;
Label1: TLabel;
StyleBook1: TStyleBook;
procedure BtnGetLinksClick(Sender: TObject);
procedure BtnExploreClick(Sender: TObject);
procedure ListBoxItem1Painting(Sender: TObject; Canvas: TCanvas; const ARect: TRectF);
procedure BtnDownloadClick(Sender: TObject);
procedure LbLinksChange(Sender: TObject);
procedure btnRemoveClick(Sender: TObject);
procedure LbDownloadsChange(Sender: TObject);
procedure btnPauseClick(Sender: TObject);
procedure BtnResumeClick(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure EdDirectChange(Sender: TObject);
private
procedure PaintItem(Sender: TObject; Canvas: TCanvas; const ARect: TRectF);
procedure ReceiveThreadDataEvent(const Sender: TObject; ThreadNo, ASpeed: Integer; AContentLength,
AReadCount: Int64; var Abort: Boolean; const VisualObject: TObject);
{ Private declarations }
public
{ Public declarations }
end;
var
FrDownloadManager: TFrDownloadManager;
implementation
uses
System.Net.HttpClient, System.RegularExpressions, System.IOUtils, System.Net.UrlClient;
{$R *.fmx}
procedure TFrDownloadManager.ReceiveThreadDataEvent(const Sender: TObject; ThreadNo: Integer; ASpeed: Integer; AContentLength, AReadCount: Int64;
var Abort: Boolean; const VisualObject: TObject);
var
LCad: string;
LCancel: Boolean;
LSpeed: Integer;
begin
LCancel := Abort;
TThread.Synchronize(nil,
procedure
begin
if AContentLength > 0 then
TListBoxItem(VisualObject).TagFloat := (AReadCount / AContentLength);
TListBoxItem(VisualObject).ItemData.Text := Format('%s %f %% completed %d/%d KB speed: %d KB/s',
[TPath.GetFileName(TListBoxItem(VisualObject).ItemData.Detail), TListBoxItem(VisualObject).TagFloat * 100,
AReadCount shr 10, AContentLength shr 10, ASpeed shr 10]);
TListBoxItem(VisualObject).Repaint;
Application.ProcessMessages;
end);
Abort := LCancel;
end;
procedure TFrDownloadManager.BtnDownloadClick(Sender: TObject);
var
LClient: THTTPClient;
URL: string;
LResponse: IHTTPResponse;
StFile: TFileStream;
LFileName: string;
LStart, LEnd, LSize, LFragSize: Int64;
I: Integer;
LDownloadThread: TDownloadThread;
LFinished: Boolean;
LStartTime, LEndTime: Cardinal;
LItem: TListBoxItem;
begin
LClient := THTTPClient.Create;
LFileName := TPath.Combine(TPath.GetDocumentsPath, EdFileName.Text);
try
if EdDirect.Text <> '' then
begin
URL := EdDirect.Text;
EdDirect.Text := '';
end
else
URL := LbLinks.Items[LbLinks.ItemIndex];
LResponse := LClient.Head(URL);
// Get space for the file that is going to be dowloaded
LSize := LResponse.ContentLength;
StFile := TFileStream.Create(LFileName, fmCreate);
try
STFile.Size := LSize;
finally
STFile.Free;
end;
LItem := TListBoxItem.Create(LbDownloads);
LItem.Parent := LbDownloads;
LItem.ItemData.Text := LFileName;
LItem.ItemData.Detail := LFileName;
LItem.OnPainting := PaintItem;
LItem.StyledSettings := [];
// Create the Thread
LDownloadThread := TDownloadThread.Create(URL, LFileName, LbDownloads.Count - 1, 0, LSize);
LDownloadThread.VisualObject := LItem;
LDownloadThread.CanResume := LClient.CheckDownloadResume(URL);
LDownloadThread.OnThreadData := ReceiveThreadDataEvent;
LItem.Data := LDownloadThread;
Application.ProcessMessages;
LDownloadThread.Start;
finally
LClient.Free;
end;
end;
procedure TFrDownloadManager.BtnExploreClick(Sender: TObject);
begin
if LbLinks.ItemIndex >= 0 then
begin
EdUrl.Text := LbLinks.Selected.Text;
BtnGetLinksClick(nil);
end;
end;
procedure TFrDownloadManager.BtnGetLinksClick(Sender: TObject);
const
ExternalLinkExp = '<A?a?[\s]+[^>]*?href[\s]?=*(.*?)[\"\'']*.*?>([^<]+|.*?)?<\/A?a?>';
var
LHttpClient: THTTPClient;
AResponse: IHTTPResponse;
LStringStream: TStringStream;
LRegex: TRegEx;
LMatchCollection: TMatchCollection;
I: Integer;
LNewRef: string;
LFirst: Integer;
LLast: Integer;
LUrl: TURI;
begin
if EdUrl.Text <> '' then
begin
LHttpClient := THTTPClient.Create;
try
AResponse := LHttpClient.Get(EdUrl.Text);
LStringStream := TStringStream.Create;
try
LStringStream.LoadFromStream(AResponse.ContentStream);
LRegex := TRegEx.Create(ExternalLinkExp);
LMatchCollection := LRegex.Matches(LStringStream.DataString);
LbLinks.Clear;
for I := 0 to LMatchCollection.Count - 1 do
begin
LNewRef := LMatchCollection.Item[I].Value;
LFirst := LNewRef.IndexOf('"');
if LFirst >=0 then
begin
LLast := LNewRef.IndexOf('"', LFirst + 1);
LNewRef := LNewRef.Substring(LFirst + 1, LLast - LFirst - 1);
if not LNewRef.StartsWith('http') then
begin
LUrl := TURI.Create(EdUrl.Text);
if LUrl.Path.EndsWith('htm', true) or LUrl.Path.EndsWith('html', true) then
LUrl.Path := '';
if LNewRef.StartsWith('/') then
LUrl.Path := LUrl.Path + LNewRef
else
LUrl.Path := LUrl.Path + '/' + LNewRef;
LNewRef := LUrl.ToString;
end;
LbLinks.items.Add(LNewRef);
end;
end;
finally
LStringStream.Free;
end;
finally
LHttpClient.Free;
end;
end;
end;
procedure TFrDownloadManager.btnPauseClick(Sender: TObject);
var
LThread: TDownloadThread;
begin
if LbDownloads.Selected <> nil then
begin
LThread := TDownloadThread(LbDownloads.Selected.Data);
LThread.PauseDownload;
LbDownloadsChange(LbDownloads);
LThread := nil;
LbDownloads.Selected.Repaint;
end;
end;
procedure TFrDownloadManager.btnRemoveClick(Sender: TObject);
var
LItem: TListBoxItem;
LThread: TDownloadThread;
begin
if LbDownloads.ItemIndex >= 0 then
begin
LItem := LbDownloads.Selected;
LThread := TDownloadThread(LItem.Data);
LItem.Data := nil;
LThread.Terminate;
LThread.Free;
LItem.Parent := nil;
LItem.Free;
end;
end;
procedure TFrDownloadManager.BtnResumeClick(Sender: TObject);
var
LThread: TDownloadThread;
begin
if LbDownloads.Selected <> nil then
begin
LThread := TDownloadThread(LbDownloads.Selected.Data);
LThread.ResumeDownload;
LbDownloadsChange(LbDownloads);
LThread := nil;
end;
end;
procedure TFrDownloadManager.EdDirectChange(Sender: TObject);
begin
EdFileName.Text := TPath.GetFileName(EdDirect.Text);
end;
procedure TFrDownloadManager.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
var
LComponent: TObject;
LThread: TDownloadThread;
I: Integer;
begin
if LbDownloads.Count > 0 then
CanClose := MessageDlg('There are downloads pending, do you want to cancel them?', TMsgDlgType.mtInformation,[TMsgDlgBtn.mbOK, TMsgDlgBtn.mbCancel],0) = mrOk;
if CanClose then
begin
for I := 0 to LbDownloads.ComponentCount - 1 do
begin
LComponent := LbDownloads.Components[I];
if LComponent is TListBoxItem then
begin
LThread := TDownloadThread(TListBoxItem(LComponent).Data);
if LThread <> nil then
begin
TListBoxItem(LComponent).Data := nil;
LThread.Terminate;
LThread.Free;
end;
end;
end;
end;
end;
procedure TFrDownloadManager.LbDownloadsChange(Sender: TObject);
var
LThread: TDownloadThread;
begin
if LbDownloads.Selected <> nil then
begin
LThread := TDownloadThread(LbDownloads.Selected.Data);
btnPause.Enabled := LThread.CanResume and not LThread.IsPaused and not LThread.Finished;
BtnResume.Enabled := LThread.IsPaused and not LThread.Finished;
LThread := nil;
end;
end;
procedure TFrDownloadManager.LbLinksChange(Sender: TObject);
begin
if LbLinks.ItemIndex >= 0 then
EdFileName.Text := TPath.GetFileName(LbLinks.Items[LbLinks.ItemIndex]);
end;
procedure TFrDownloadManager.ListBoxItem1Painting(Sender: TObject; Canvas: TCanvas; const ARect: TRectF);
begin
PaintItem(Sender, Canvas, ARect);
end;
procedure TFrDownloadManager.PaintItem(Sender: TObject; Canvas: TCanvas; const ARect: TRectF);
var
LCorner: TCorners;
LBrush: TBrush;
LRect1, LRect2 : TRectF;
begin
if TListBoxItem(Sender).Data = nil then exit;
LCorner := [TCorner.TopLeft, TCorner.TopRight, TCorner.BottomLeft, TCorner.BottomRight];
LBrush := TBrush.Create(TBrushKind.Solid, TAlphaColorRec.Greenyellow);
LRect1 := ARect;
LRect1.Right := LRect1.Left + ((LRect1.Right - LRect1.Left) * TListBoxItem(Sender).TagFloat);
try
if TListBoxItem(Sender) = LbDownloads.Selected then
LBrush.Color := TAlphaColorRec.Lightgrey
else
LBrush.Color := TAlphaColorRec.White;
Canvas.FillRect(ARect, 1, 1, LCorner, 1, LBrush);
if TDownloadThread(TListBoxItem(Sender).Data).IsPaused then
begin
if TListBoxItem(Sender) = LbDownloads.Selected then
LBrush.Color := TAlphaColorRec.Lightgoldenrodyellow
else
LBrush.Color := TAlphaColorRec.Yellow;
end
else
begin
if TListBoxItem(Sender) = LbDownloads.Selected then
LBrush.Color := TAlphaColorRec.Lightgreen
else
LBrush.Color := TAlphaColorRec.Greenyellow;
end;
Canvas.FillRect(Lrect1, 1, 1, LCorner, 1, LBrush);
finally
LBrush.Free;
end;
end;
end.
|
unit ibSHDataGridFrm;
interface
uses
SHDesignIntf, SHOptionsIntf,
ibSHDesignIntf, ibSHDriverIntf, ibSHDataCustomFrm,
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls, ToolWin, ExtCtrls, SynEdit, pSHSynEdit, Grids, DBGrids,
DBGridEh, DbUtilsEh, ImgList, DB, DBCtrls, ActnList, AppEvnts, PrnDbgeh, TypInfo,
Menus, StdCtrls, GridsEh;
type
TibSHDataGridForm = class(TibSHDataCustomForm)
Panel1: TPanel;
Panel2: TPanel;
pSHSynEdit2: TpSHSynEdit;
Splitter1: TSplitter;
ImageList1: TImageList;
DataSource1: TDataSource;
sdGrid: TSaveDialog;
PrintDBGridEh1: TPrintDBGridEh;
PopupMenuMessage: TPopupMenu;
pmiHideMessage: TMenuItem;
DBGridEh1: TDBGridEh;
ApplicationEvents1: TApplicationEvents;
Panel3: TPanel;
ToolBar1: TToolBar;
DBNavigator1: TDBNavigator;
procedure ControlBar1Resize(Sender: TObject);
procedure DataSource1DataChange(Sender: TObject; Field: TField);
procedure DataSource1StateChange(Sender: TObject);
procedure pmiHideMessageClick(Sender: TObject);
procedure ApplicationEvents1Idle(Sender: TObject; var Done: Boolean);
private
procedure GutterDrawNotify(Sender: TObject; ALine: Integer; var ImageIndex: Integer);
{ Private declarations }
protected
procedure ShowMessages; override;
procedure HideMessages; override;
{IibDRVDatasetNotification}
procedure OnFetchRecord(ADataset: IibSHDRVDataset); override;
{ISHFileCommands}
function GetCanSave: Boolean; override;
function GetCanSaveAs: Boolean; override;
function GetCanPrint: Boolean; override;
procedure Save; override;
procedure SaveAs; override;
procedure Print; override;
{End ISHFileCommands}
{ ISHSearchCommands }
function GetCanFind: Boolean; override;
function GetCanReplace: Boolean; override;
function GetCanSearchAgain: Boolean; override;
function GetCanSearchIncremental: Boolean; override;
function GetCanGoToLineNumber: Boolean; override;
procedure Find; override;
procedure Replace; override;
procedure SearchAgain; override;
procedure SearchIncremental; override;
{ISHEditCommands}
function GetCanUndo: Boolean; override;
function GetCanRedo: Boolean; override;
function GetCanSelectAll: Boolean; override;
function GetCanClearAll: Boolean; override;
procedure Undo; override;
// procedure Redo;
procedure SelectAll; override;
{End ISHEditCommands}
procedure DoOnIdle; override;
function GetCanDestroy: Boolean; override;
public
{ Public declarations }
constructor Create(AOwner: TComponent; AParent: TWinControl;
AComponent: TSHComponent; ACallString: string); override;
destructor Destroy; override;
procedure BringToTop; override;
end;
TibSHDataGridToolbarAction_Refresh = class(TibSHDataCustomToolbarAction_Refresh)
end;
TibSHDataGridToolbarAction_Commit = class(TibSHDataCustomToolbarAction_Commit)
end;
TibSHDataGridToolbarAction_Rollback = class(TibSHDataCustomToolbarAction_Rollback)
end;
TibSHDataGridToolbarAction_Filter = class(TibSHDataCustomToolbarAction_Filter)
end;
TibSHDataGridToolbarAction_Pause = class(TibSHDataCustomToolbarAction_Pause)
end;
TibSHDataGridToolbarAction_BackToQuery = class(TibSHDataCustomToolbarAction_BackToQuery)
end;
TibSHDataGridToolbarAction_Open = class(TibSHDataCustomToolbarAction_Open)
end;
TibSHDataGridToolbarAction_Save = class(TibSHDataCustomToolbarAction_Save)
end;
TibSHDataGridToolbarAction_ExportToExcel = class(TibSHDataCustomToolbarAction_Export2Excel)
end;
TibSHDataGridToolbarAction_ExportToOOCalc = class(TibSHDataCustomToolbarAction_Export2OO)
end;
procedure Register();
var
ibSHDataGridForm: TibSHDataGridForm;
implementation
uses
ibSHConsts, ibSHValues, ibSHMessages, Clipbrd;
procedure Register();
begin
SHREgisterImage(TibSHDataGridToolbarAction_Refresh.ClassName, 'Button_Refresh.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Commit.ClassName, 'Button_TrCommit.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Rollback.ClassName, 'Button_TrRollback.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Filter.ClassName, 'Button_RunFilter.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Pause.ClassName, 'Button_Stop.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_BackToQuery.ClassName, 'Button_Query_Prev.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Open.ClassName, 'Button_Open.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_Save.ClassName, 'Button_Save.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_ExportToExcel.ClassName,'Button_Excel.bmp');
SHREgisterImage(TibSHDataGridToolbarAction_ExportToOOCalc.ClassName,'Button_scalc.bmp');
SHRegisterActions([
// Toolbar
TibSHDataGridToolbarAction_BackToQuery,
TibSHDataGridToolbarAction_Pause,
TibSHDataGridToolbarAction_Commit,
TibSHDataGridToolbarAction_Rollback,
TibSHDataGridToolbarAction_Filter,
TibSHDataGridToolbarAction_Refresh,
TibSHDataGridToolbarAction_Open,
TibSHDataGridToolbarAction_Save,
TibSHDataGridToolbarAction_ExportToExcel,
TibSHDataGridToolbarAction_ExportToOOCalc
]);
end;
{$R *.dfm}
{ TibBTDataForm }
constructor TibSHDataGridForm.Create(AOwner: TComponent; AParent: TWinControl;
AComponent: TSHComponent; ACallString: string);
begin
inherited Create(AOwner, AParent, AComponent, ACallString);
DBGrid := DBGridEh1;
FocusedControl := DBGridEh1;
ResultEdit := pSHSynEdit2;
ResultEdit.Lines.Clear;
ResultEdit.OnGutterDraw := GutterDrawNotify;
ResultEdit.GutterDrawer.ImageList := ImageList1;
ResultEdit.GutterDrawer.Enabled := True;
HideMessages;
CatchRunTimeOptionsDemon;
DoOnOptionsChanged;
if Assigned(Data) and Assigned(SHCLDatabase) then
DataSource1.DataSet := Data.Dataset.Dataset;
end;
destructor TibSHDataGridForm.Destroy;
begin
inherited Destroy;
end;
procedure TibSHDataGridForm.ControlBar1Resize(Sender: TObject);
begin
ToolBar1.Width := ToolBar1.Parent.ClientWidth;
end;
procedure TibSHDataGridForm.DataSource1DataChange(Sender: TObject;
Field: TField);
begin
if Assigned(DataSource1.DataSet) then
DoUpdateStatusBar;
end;
procedure TibSHDataGridForm.DataSource1StateChange(Sender: TObject);
begin
if Assigned(DataSource1.DataSet) then
DoUpdateStatusBar;
end;
procedure TibSHDataGridForm.GutterDrawNotify(Sender: TObject; ALine: Integer;
var ImageIndex: Integer);
begin
if ALine = 0 then ImageIndex := 1;
end;
procedure TibSHDataGridForm.ShowMessages;
begin
Panel2.Visible := True;
Splitter1.Visible := True;
end;
procedure TibSHDataGridForm.HideMessages;
begin
Panel2.Visible := False;
Splitter1.Visible := False;
end;
procedure TibSHDataGridForm.OnFetchRecord(ADataset: IibSHDRVDataset);
begin
if EnabledFetchEvent then
begin
if Assigned(SHCLDatabase) and (not SHCLDatabase.WasLostConnect) then
begin
DoUpdateStatusBar;
Application.ProcessMessages;
Designer.UpdateActions;
if Assigned(SHCLDatabase) and (SHCLDatabase.WasLostConnect) then
begin
Data.Dataset.IsFetching := False;
Exit;
end;
end
else
if Assigned(SHCLDatabase) and (SHCLDatabase.WasLostConnect) then
Data.Dataset.IsFetching := False;
end;
end;
function TibSHDataGridForm.GetCanSave: Boolean;
begin
Result := Assigned(SHCLDatabase) and (not SHCLDatabase.WasLostConnect) and
Assigned(Data) and Data.Dataset.Active;
end;
function TibSHDataGridForm.GetCanSaveAs: Boolean;
begin
Result := GetCanSave and (ActiveControl is TDBGridEh);
end;
function TibSHDataGridForm.GetCanPrint: Boolean;
begin
Result := GetCanSave;
end;
procedure TibSHDataGridForm.Save;
var
vDataSaver: ISHDataSaver;
vServerOptions: IibSHServerOptions;
I, J: Integer;
vFilter: string;
vFileName: string;
vInputExt: string;
vExt: TStringList;
vSaved: Boolean;
begin
vFilter := '';
vExt := TStringList.Create;
try
for I := Pred(Designer.Components.Count) downto 0 do
if Supports(Designer.Components[I], ISHDataSaver, vDataSaver) then
for J := 0 to Pred(vDataSaver.SupportsExtentions.Count) do
begin
if vExt.IndexOf(vDataSaver.SupportsExtentions[J]) = -1 then
begin
vExt.Add(vDataSaver.SupportsExtentions[J]);
vFilter := vFilter +
Format(SExportExtentionTemplate,
[vDataSaver.ExtentionDescriptions[J],
vDataSaver.SupportsExtentions[J],
vDataSaver.SupportsExtentions[J]]) + '|';
end;
end;
if Length(vFilter) > 0 then
begin
Delete(vFilter, Length(vFilter), 1);
sdGrid.Filter := vFilter;
(* dk: заремил 27.06.2004 по причине сноса проперти DatabaseAliaOptions.Paths
if Supports(Designer.GetOptions(ISHSystemOptions), ISHSystemOptions, vSystemOptions) then
sdGrid.InitialDir := BTCLDatabase.DatabaseAliasOptions.Paths.ForExtracts;
*)
if IsEqualGUID(Component.BranchIID, IibSHBranch) then
Supports(Designer.GetOptions(IibSHServerOptions), IibSHServerOptions, vServerOptions)
else
if IsEqualGUID(Component.BranchIID, IfbSHBranch) then
Supports(Designer.GetOptions(IfbSHServerOptions), IibSHServerOptions, vServerOptions);
if Assigned(vServerOptions) then
sdGrid.FilterIndex := vServerOptions.SaveResultFilterIndex;
if sdGrid.Execute then
begin
vFileName := sdGrid.FileName;
vInputExt := ExtractFileExt(sdGrid.FileName);
if not SameText(vInputExt, vExt[sdGrid.FilterIndex - 1]) then
vFileName := ChangeFileExt(vFileName, vExt[sdGrid.FilterIndex - 1]);
vSaved := False;
for I := Pred(Designer.Components.Count) downto 0 do
if Supports(Designer.Components[I], ISHDataSaver, vDataSaver) then
begin
if vDataSaver.SupportsExtentions.IndexOf(vInputExt) <> -1 then
begin
vDataSaver.SaveToFile(Component, Data.Dataset.Dataset, DBGridEh1, vFileName);
vSaved := True;
Break;
end;
end;
if vSaved and Assigned(vServerOptions) then
begin
vServerOptions.SaveResultFilterIndex := sdGrid.FilterIndex;
end;
end;
end
else
Designer.ShowMsg(SNoExportersRegisted, mtWarning);
finally
vExt.Free;
end;
end;
procedure TibSHDataGridForm.SaveAs;
begin
Save;
end;
procedure TibSHDataGridForm.Print;
begin
if GetCanPrint then
PrintDBGridEh1.Preview;
end;
function TibSHDataGridForm.GetCanFind: Boolean;
begin
Result := False;
end;
function TibSHDataGridForm.GetCanReplace: Boolean;
begin
Result := False;
end;
function TibSHDataGridForm.GetCanSearchAgain: Boolean;
begin
Result := False;
end;
function TibSHDataGridForm.GetCanSearchIncremental: Boolean;
begin
Result := False;
end;
function TibSHDataGridForm.GetCanGoToLineNumber: Boolean;
begin
Result := False;
end;
procedure TibSHDataGridForm.Find;
begin
//
end;
procedure TibSHDataGridForm.Replace;
begin
//
end;
procedure TibSHDataGridForm.SearchAgain;
begin
//
end;
procedure TibSHDataGridForm.SearchIncremental;
begin
//
end;
function TibSHDataGridForm.GetCanUndo: Boolean;
begin
Result := GetCanSave and
Assigned(DBGrid) and
Assigned(DBGrid.InplaceEditor) and
DBGrid.InplaceEditor.Visible and
DBGrid.InplaceEditor.CanUndo;
end;
function TibSHDataGridForm.GetCanRedo: Boolean;
begin
Result := False;
end;
function TibSHDataGridForm.GetCanSelectAll: Boolean;
begin
Result := GetCanSave
or
(Assigned(DBGrid) and
Assigned(DBGrid.InplaceEditor) and
DBGrid.InplaceEditor.Visible);
end;
function TibSHDataGridForm.GetCanClearAll: Boolean;
begin
Result := False;
end;
procedure TibSHDataGridForm.Undo;
begin
if GetCanUndo then
DBGrid.InplaceEditor.Undo;
end;
procedure TibSHDataGridForm.SelectAll;
begin
if GetCanSelectAll then
if Assigned(DBGrid) and Assigned(DBGrid.InplaceEditor) and DBGrid.InplaceEditor.Visible then
DBGrid.InplaceEditor.SelectAll
else
DBGridEh1.Selection.SelectAll;
end;
procedure TibSHDataGridForm.DoOnIdle;
begin
inherited DoOnIdle;
DoUpdateStatusBar;
end;
function TibSHDataGridForm.GetCanDestroy: Boolean;
begin
Result := True;
if (not Designer.ExistsComponent(Component, SCallDataBLOB)) and
(not Designer.ExistsComponent(Component, SCallDataForm)) then
Result := inherited GetCanDestroy;
end;
procedure TibSHDataGridForm.BringToTop;
begin
if Assigned(Data) then
Data.Dataset.DatasetNotification := Self as IibDRVDatasetNotification;
inherited BringToTop;
end;
procedure TibSHDataGridForm.pmiHideMessageClick(Sender: TObject);
begin
HideMessages;
end;
procedure TibSHDataGridForm.ApplicationEvents1Idle(Sender: TObject;
var Done: Boolean);
begin
DoOnIdle;
end;
initialization
Register();
end.
|
unit uDocwikiProxy_VCL;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, IdHTTPProxyServer, IdCmdTCPServer,
IdContext, IdServerIOHandler, IdServerIOHandlerSocket, IdServerIOHandlerStack,
IdAntiFreezeBase, Vcl.IdAntiFreeze, Vcl.StdCtrls, IdBaseComponent,
IdComponent, IdCustomTCPServer, IdTCPServer, Vcl.WinXCtrls, Vcl.ExtCtrls,
RegularExpressions;
type
TForm1 = class(TForm)
IdHTTPProxyServer1: TIdHTTPProxyServer;
Memo1: TMemo;
IdAntiFreeze1: TIdAntiFreeze;
IdServerIOHandlerStack1: TIdServerIOHandlerStack;
Panel1: TPanel;
ToggleSwitch1: TToggleSwitch;
Label1: TLabel;
procedure IdHTTPProxyServer1HTTPResponse(
AContext: TIdHTTPProxyServerContext);
procedure IdHTTPProxyServer1HTTPBeforeCommand(
AContext: TIdHTTPProxyServerContext);
procedure FormCreate(Sender: TObject);
private
{ Private 宣言 }
FlagResponseHeaderStrip: Boolean;
HeaderList: TStringList;
procedure WriteToMemo(AHeaderName: String; AHeaderValue: String);
public
{ Public 宣言 }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
{
フォーム生成時の処理
・削除対象のレスポンスヘッダ名のリストを初期化する。
}
begin
HeaderList := TSTringList.Create;
HeaderList.CommaText := 'Expires,Pragma,Vary';
end;
procedure TForm1.IdHTTPProxyServer1HTTPBeforeCommand(
AContext: TIdHTTPProxyServerContext);
{
クライアントからのリクエスト受信時の処理
}
begin
{
リクエストヘッダに関する処理を行いたいにここで処理可能。
以下の例はリクエストヘッダに含まれる Cache-Control ヘッダを消去する処理。
if (AContext.Headers.IndexOfName('Cache-Control') > 0) then
AContext.Headers.Delete( AContext.Headers.IndexOfName('Cache-Control') );
end;
}
end;
procedure TForm1.IdHTTPProxyServer1HTTPResponse(
AContext: TIdHTTPProxyServerContext);
{ サーバからのレスポンスをクライアントに返す前に行う処理 }
var
NameIndex: Integer;
i: Integer;
begin
// ブラウザキャッシュを阻害するヘッダの削除を行う処理。
// 接続先が docwiki.embarcadero.com 以外ならばここで終了
if (not AContext.Target.startsWith('http://docwiki.embarcadero.com') ) then
exit;
// Switch1 が On (動作の詳細表示有効) ならば、空行を１行差し込む。
// これはレイアウト調整を目的としている。
if ToggleSwitch1.isOn then
Memo1.Lines.Insert(0, ' ');
// リクエストされたURLをログ用の Memo の先頭行に差し込む。
Memo1.Lines.Insert(0, AContext.Target);
// 削除対象の HTTP レスポンスヘッダを探して消す。
// ただし Cache-Control は別の個所で処理する。
for NameIndex := 0 to HeaderList.Count - 1 do begin
if (AContext.Headers.IndexOfName(HeaderList[NameIndex]) > 0) then
begin
WriteToMemo( ' remove ' + HeaderList[NameIndex] ,AContext.Headers.Values[HeaderList[NameIndex]] );
AContext.Headers.Delete( AContext.Headers.IndexOfName(HeaderList[NameIndex]) );
end;
end;
// Cache-Control については、private の場合だけ消す。
if ( Length(AContext.Headers.Values['Cache-Control']) > 0 ) then
if TRegEx.IsMatch(AContext.Headers.Values['Cache-Control'],'[Pp]rivate') then
begin
WriteToMemo( ' remove Cache-Control', AContext.Headers.Values['Cache-Control'] );
AContext.Headers.Delete( AContext.Headers.IndexOfName('Cache-Control') );
end;
end;
procedure TForm1.WriteToMemo(AHeaderName: string; AHeaderValue: string);
{ TMemo へのメッセージ書き出し処理 }
begin
// Switch1 がチェックされていない場合は処理を行わない。
if not ToggleSwitch1.isOn then
exit;
if AHeaderValue.Length > 0 then
Memo1.Lines.Insert(1, AHeaderName + ' = ' + AHeaderValue);
end;
end.
|
unit AqDrop.DB.ORM.Manager;
interface
uses
System.SysUtils,
AqDrop.Core.InterfacedObject,
AqDrop.Core.Collections.Intf,
AqDrop.Core.Collections,
AqDrop.DB.Types,
AqDrop.DB.Connection,
AqDrop.DB.SQL.Intf,
AqDrop.DB.Adapter;
type
TAqDBORMManager = class;
TAqDBORMManagerClient = class
strict private
[weak]
FORMManager: TAqDBORMManager;
private
class function CreateNew(const pORMManager: TAqDBORMManager): TAqDBORMManagerClient;
strict protected
procedure StartTransaction;
procedure CommitTransaction;
procedure RollbackTransaction;
public
constructor Create; virtual;
property ORMManager: TAqDBORMManager read FORMManager;
end;
TAqDBORMManager = class
strict private
FConnection: TAqDBConnection;
FClients: TAqDictionary<string, TAqDBORMManagerClient>;
procedure FillParametersWithObjectValues(pParameters: IAqDBParameters; const pObject: TObject);
function GetAdapter: TAqDBAdapter;
function GetSQLSolver: TAqDBSQLSolver;
class var FDefault: TAqDBORMManager;
strict protected
property Adapter: TAqDBAdapter read GetAdapter;
property SQLSolver: TAqDBSQLSolver read GetSQLSolver;
public
constructor Create(const pConnection: TAqDBConnection);
destructor Destroy; override;
function BuildBaseSelect(const pClass: TClass): IAqDBSQLSelect;
function BuildSelect(const pClass: TClass): IAqDBSQLSelect;
function BuildBaseInserts(const pClass: TClass): IAqResultList<IAqDBSQLInsert>;
function BuildInserts(const pClass: TClass): IAqResultList<IAqDBSQLInsert>;
function BuildBaseUpdates(const pClass: TClass): IAqResultList<IAqDBSQLUpdate>;
function BuildUpdates(const pClass: TClass): IAqResultList<IAqDBSQLUpdate>;
function BuildBaseDeletes(const pClass: TClass): IAqResultList<IAqDBSQLDelete>;
function BuildDeletes(const pClass: TClass): IAqResultList<IAqDBSQLDelete>;
function CreateFilter: IAqDBSQLComposedCondition;
function Get<T: class, constructor>(out pResultList: IAqResultList<T>): Boolean; overload;
function Get<T: class, constructor>(pSelect: IAqDBSQLSelect; out pResultList: IAqResultList<T>): Boolean; overload;
function Get<T: class, constructor>(const pSelect: string; out pResultList: IAqResultList<T>): Boolean; overload;
function Get<T: class, constructor>(pFilter: IAqDBSQLComposedCondition;
out pResultList: IAqResultList<T>): Boolean; overload;
function Get<T: class, constructor>(const pCustomizationMethod: TProc<IAqDBSQLSelect>;
out pResultList: IAqResultList<T>): Boolean; overload;
function Get<T: class, constructor>:IAqResultList<T>; overload;
function Get<T: class, constructor>(pSelect: IAqDBSQLSelect): IAqResultList<T>; overload;
function Get<T: class, constructor>(pSelect: string): IAqResultList<T>; overload;
function Get<T: class, constructor>(pFilter: IAqDBSQLComposedCondition): IAqResultList<T>; overload;
function Get<T: class, constructor>(
const pCustomizationMethod: TProc<IAqDBSQLSelect>): IAqResultList<T>; overload;
function GetByID<T: class, constructor>(const pID: Int64; out pResult: T): Boolean; overload;
function GetByID<T: class, constructor>(const pID: Int64): T; overload;
procedure Add(const pObject: TObject; const pFreeObject: Boolean = False); overload;
procedure Add(const pInserts: IAqReadList<IAqDBSQLInsert>; const pObject: TObject); overload;
procedure Add(const pInsert: IAqDBSQLInsert; const pObject: TObject); overload;
procedure Add<T: class>(const pCustomizationMethod: TProc<IAqDBSQLInsert>); overload;
procedure Update(const pObject: TObject; const pFreeObject: Boolean = False); overload;
procedure Update(const pUpdates: IAqReadList<IAqDBSQLUpdate>; const pObject: TObject); overload;
procedure Update(const pUpdate: IAqDBSQLUpdate; const pObject: TObject); overload;
procedure Update<T: class>(const pCustomizationMethod: TProc<IAqDBSQLUpdate>); overload;
procedure Delete(const pObject: TObject; const pFreeObject: Boolean = True); overload;
procedure Delete(const pDeletes: IAqReadList<IAqDBSQLDelete>; const pObject: TObject); overload;
procedure Delete(const pDelete: IAqDBSQLDelete; const pObject: TObject); overload;
procedure Delete<T: class>(const pCustomizationMethod: TProc<IAqDBSQLDelete>); overload;
procedure Post(const pObject: TObject; const pFreeObject: Boolean = False);
function ExecuteWithObject(const pSQLCommand: string; const pObject: TObject): Int64;
function GetClient<T: TAqDBORMManagerClient>: T;
property Connection: TAqDBConnection read FConnection;
class property Default: TAqDBORMManager read FDefault write FDefault;
end;
implementation
uses
System.Rtti,
AqDrop.Core.Types,
AqDrop.Core.Exceptions,
AqDrop.DB.ORM.Reader,
AqDrop.DB.SQL,
AqDrop.DB.ORM.Attributes;
{ TAqDBORMManager }
constructor TAqDBORMManager.Create(const pConnection: TAqDBConnection);
begin
FConnection := pConnection;
FConnection.AddDependent(Self);
FClients := TAqDictionary<string, TAqDBORMManagerClient>.Create([TAqDictionaryContent.adcValue], True);
end;
function TAqDBORMManager.CreateFilter: IAqDBSQLComposedCondition;
begin
Result := TAqDBSQLComposedCondition.Create;
end;
procedure TAqDBORMManager.Delete(const pDeletes: IAqReadList<IAqDBSQLDelete>; const pObject: TObject);
var
lDelete: IAqDBSQLDelete;
begin
FConnection.StartTransaction;
try
for lDelete in pDeletes do
begin
Delete(lDelete, pObject);
end;
FConnection.CommitTransaction;
except
FConnection.RollbackTransaction;
raise;
end;
end;
procedure TAqDBORMManager.Delete(const pDelete: IAqDBSQLDelete; const pObject: TObject);
begin
ExecuteWithObject(SQLSolver.SolveDelete(pDelete), pObject);
end;
procedure TAqDBORMManager.Delete<T>(const pCustomizationMethod: TProc<IAqDBSQLDelete>);
var
lDeletes: IAqResultList<IAqDBSQLDelete>;
lDelete: IAqDBSQLDelete;
lFilter: IAqDBSQLComposedCondition;
begin
lDeletes := BuildBaseDeletes(T);
Connection.StartTransaction;
try
for lDelete in lDeletes do
begin
pCustomizationMethod(lDelete);
Connection.ExecuteCommand(lDelete);
end;
Connection.CommitTransaction;
except
on E: Exception do
begin
Connection.RollbackTransaction;
E.RaiseOuterException(EAqInternal.Create('Impossible to execute the custom delete.'));
end;
end;
end;
destructor TAqDBORMManager.Destroy;
begin
FClients.Free;
FConnection.RemoveDependent(Self);
inherited;
end;
procedure TAqDBORMManager.Delete(const pObject: TObject; const pFreeObject: Boolean);
begin
Delete(BuildDeletes(pObject.ClassType), pObject);
{$IFNDEF AUTOREFCOUNT}
if pFreeObject then
begin
pObject.Free;
end;
{$ENDIF}
end;
procedure TAqDBORMManager.FillParametersWithObjectValues(pParameters: IAqDBParameters; const pObject: TObject);
var
lI: Int32;
lColumn: TAqDBORMColumn;
lORM: TAqDBORM;
begin
lORM := TAqDBORMReader.GetORM(pObject.ClassType);
for lI := 0 to pParameters.Count - 1 do
begin
if lORM.GetColumn(pParameters[lI].Name, lColumn) then
begin
lColumn.SetDBValue(pObject, pParameters[lI]);
end;
end;
end;
function TAqDBORMManager.Get<T>(out pResultList: IAqResultList<T>): Boolean;
begin
Result := Get<T>(BuildSelect(T), pResultList);
end;
function TAqDBORMManager.Get<T>(pSelect: IAqDBSQLSelect; out pResultList: IAqResultList<T>): Boolean;
begin
Result := Get<T>(SQLSolver.SolveSelect(pSelect), pResultList);
end;
function TAqDBORMManager.Get<T>(const pSelect: string; out pResultList: IAqResultList<T>): Boolean;
var
lORM: TAqDBORM;
lReader: IAqDBReader;
lList: TAqResultList<T>;
lObject: T;
lI: Int32;
lColumn: TAqDBORMColumn;
begin
Result := False;
lList := nil;
try
lReader := FConnection.OpenQuery(pSelect);
while lReader.Next do
begin
if not Result then
begin
lORM := TAqDBORMReader.GetORM(T);
Result := True;
lList := TAqResultList<T>.Create(True);
end;
lList.Add(T.Create);
lObject := lList.Last;
for lI := 0 to lReader.Count - 1 do
begin
if lORM.GetColumn(lReader[lI].Name, lColumn) then
begin
lColumn.SetObjectValue(lObject, lReader[lI]);
end;
end;
end;
except
lList.Free;
raise;
end;
if Result then
begin
pResultList := lList;
end;
end;
procedure TAqDBORMManager.Add(const pObject: TObject; const pFreeObject: Boolean);
begin
Add(BuildInserts(pObject.ClassType), pObject);
{$IFNDEF AUTOREFCOUNT}
if pFreeObject then
begin
pObject.Free;
end;
{$ENDIF}
end;
procedure TAqDBORMManager.Post(const pObject: TObject; const pFreeObject: Boolean = False);
var
lInserts: IAqResultList<IAqDBSQLInsert>;
lUpdates: IAqResultList<IAqDBSQLUpdate>;
lI: Int32;
lSelect: IAqDBSQLSelect;
lReader: IAqDBReader;
begin
{$IFNDEF AUTOREFCOUNT}
try
{$ENDIF}
lInserts := BuildInserts(pObject.ClassType);
lUpdates := BuildUpdates(pObject.ClassType);
if lInserts.Count <> lUpdates.Count then
begin
raise EAqInternal.Create('Inserts and Updates of ' + pObject.ClassName + ' has diferent counts.');
end;
FConnection.StartTransaction;
try
for lI := 0 to lUpdates.Count - 1 do
begin
lSelect := TAqDBSQLSelect.Create(lUpdates[lI].Table.Name);
lSelect.AddColumn(TAqDBSQLIntConstant.Create(1));
lSelect.Condition := lUpdates[lI].Condition;
lSelect.Limit := 1;
lReader := FConnection.OpenQuery(lSelect,
procedure(pParameters: IAqDBParameters)
begin
FillParametersWithObjectValues(pParameters, pObject);
end);
if lReader.Next then
begin
Update(lUpdates[lI], pObject);
end else begin
Add(lInserts[lI], pObject);
end;
end;
FConnection.CommitTransaction;
except
FConnection.RollbackTransaction;
raise;
end;
{$IFNDEF AUTOREFCOUNT}
finally
if pFreeObject then
begin
pObject.Free;
end;
end;
{$ENDIF}
end;
procedure TAqDBORMManager.Update(const pUpdates: IAqReadList<IAqDBSQLUpdate>; const pObject: TObject);
var
lUpdate: IAqDBSQLUpdate;
begin
FConnection.StartTransaction;
try
for lUpdate in pUpdates do
begin
Update(lUpdate, pObject);
end;
FConnection.CommitTransaction;
except
FConnection.RollbackTransaction;
raise;
end;
end;
procedure TAqDBORMManager.Update(const pUpdate: IAqDBSQLUpdate; const pObject: TObject);
begin
ExecuteWithObject(SQLSolver.SolveUpdate(pUpdate), pObject);
end;
procedure TAqDBORMManager.Update<T>(const pCustomizationMethod: TProc<IAqDBSQLUpdate>);
var
lUpdates: IAqResultList<IAqDBSQLUpdate>;
lUpdate: IAqDBSQLUpdate;
begin
lUpdates := BuildBaseUpdates(T);
Connection.StartTransaction;
try
for lUpdate in lUpdates do
begin
pCustomizationMethod(lUpdate);
Connection.ExecuteCommand(lUpdate);
end;
except
Connection.RollbackTransaction;
raise EAqInternal.Create('Impossible to execute the custom update.');
end;
end;
procedure TAqDBORMManager.Update(const pObject: TObject; const pFreeObject: Boolean);
begin
Update(BuildUpdates(pObject.ClassType), pObject);
{$IFNDEF AUTOREFCOUNT}
if pFreeObject then
begin
pObject.Free;
end;
{$ENDIF}
end;
procedure TAqDBORMManager.Add(const pInsert: IAqDBSQLInsert; const pObject: TObject);
var
lORM: TAqDBORM;
lHasAutoIncrementColumn: Boolean;
lTable: TAqDBORMTable;
lAutoIncrementColumn: TAqDBORMColumn;
lGeneratorName: string;
begin
lORM := TAqDBORMReader.GetORM(pObject.ClassType);
lHasAutoIncrementColumn := lORM.GetTable(pInsert.Table.Name, lTable) and
lTable.HasAutoIncrementColumn(lAutoIncrementColumn);
FConnection.StartTransaction;
try
if lHasAutoIncrementColumn and (Adapter.AutoIncrementType = TAqDBAutoIncrementType.aiGenerator) then
begin
if Assigned(lAutoIncrementColumn.Attribute) and (lAutoIncrementColumn.Attribute is AqAutoIncrementColumn) and
AqAutoIncrementColumn(lAutoIncrementColumn.Attribute).IsGeneratorDefined then
begin
lGeneratorName := AqAutoIncrementColumn(lAutoIncrementColumn.Attribute).GeneratorName;
end else begin
lGeneratorName := SQLSolver.SolveGeneratorName(lTable.Name);
end;
lAutoIncrementColumn.SetObjectValue(pObject, TValue.From<Int64>(FConnection.GetAutoIncrement(lGeneratorName)));
end;
ExecuteWithObject(SQLSolver.SolveInsert(pInsert), pObject);
if lHasAutoIncrementColumn and (Adapter.AutoIncrementType = TAqDBAutoIncrementType.aiAutoIncrement) then
begin
lAutoIncrementColumn.SetObjectValue(pObject, TValue.From<Int64>(FConnection.GetAutoIncrement));
end;
FConnection.CommitTransaction;
except
FConnection.RollbackTransaction;
raise;
end;
end;
procedure TAqDBORMManager.Add<T>(const pCustomizationMethod: TProc<IAqDBSQLInsert>);
var
lInserts: IAqResultList<IAqDBSQLInsert>;
lInsert: IAqDBSQLInsert;
begin
lInserts := BuildBaseInserts(T);
Connection.StartTransaction;
try
for lInsert in lInserts do
begin
pCustomizationMethod(lInsert);
Connection.ExecuteCommand(lInsert);
end;
except
Connection.RollbackTransaction;
raise EAqInternal.Create('Impossible to execute the custom insert.');
end;
end;
procedure TAqDBORMManager.Add(const pInserts: IAqReadList<IAqDBSQLInsert>; const pObject: TObject);
var
lInsert: IAqDBSQLInsert;
begin
FConnection.StartTransaction;
try
for lInsert in pInserts do
begin
Add(lInsert, pObject);
end;
FConnection.CommitTransaction;
except
FConnection.RollbackTransaction;
raise;
end;
end;
function TAqDBORMManager.BuildBaseDeletes(const pClass: TClass): IAqResultList<IAqDBSQLDelete>;
var
lORM: TAqDBORM;
lDeletes: TAqResultList<IAqDBSQLDelete>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lDeletes := TAqResultList<IAqDBSQLDelete>.Create;
try
lDeletes.Add(TAqDBSQLDelete.Create(lORM.MainTable.Name));
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
lDeletes.Insert(0, TAqDBSQLDelete.Create(lSpecialization.Name));
end;
end;
except
lDeletes.Free;
raise;
end;
Result := lDeletes;
end;
function TAqDBORMManager.BuildBaseInserts(const pClass: TClass): IAqResultList<IAqDBSQLInsert>;
var
lORM: TAqDBORM;
lInserts: TAqResultList<IAqDBSQLInsert>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lInserts := TAqResultList<IAqDBSQLInsert>.Create;
try
lInserts.Add(TAqDBSQLInsert.Create(lORM.MainTable.Name));
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
lInserts.Add(TAqDBSQLInsert.Create(lSpecialization.Name));
end;
end;
except
lInserts.Free;
raise;
end;
Result := lInserts;
end;
function TAqDBORMManager.BuildBaseSelect(const pClass: TClass): IAqDBSQLSelect;
var
lSelect: TAqDBSQLSelect;
lORM: TAqDBORM;
lSpecialization: TAqDBORMTable<AqSpecialization>;
lCondition: TAqDBSQLComposedCondition;
lLink: TAqDBLink;
lMasterSource: TAqDBSQLSource;
lDetail: TAqDBSQLSource;
procedure AddLinkCondition(const pCondition: TAqDBSQLCondition);
begin
if not Assigned(lCondition) then
begin
lCondition := TAqDBSQLComposedCondition.Create(pCondition);
end else begin
lCondition.AddCondition(TAqDBSQLBooleanOperator.boAnd, pCondition);
end;
end;
begin
lSelect := nil;
try
lORM := TAqDBORMReader.GetORM(pClass);
lMasterSource := TAqDBSQLTable.Create(lORM.MainTable.Name);
lSelect := TAqDBSQLSelect.Create(lMasterSource);
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
if lSpecialization.Attribute.Links.Count = 0 then
begin
raise EAqInternal.Create('The specialization has no links.');
end;
lDetail := TAqDBSQLTable.Create(lSpecialization.Name);
lCondition := nil;
for lLink in lSpecialization.Attribute.Links do
begin
AddLinkCondition(TAqDBSQLComparisonCondition.Create(
TAqDBSQLColumn.Create(lLink.MasterKey, lMasterSource),
TAqDBSQLComparison.cpEqual,
TAqDBSQLColumn.Create(lLink.ForeignKey, lDetail)));
end;
lSelect.AddJoin(TAqDBSQLJoinType.jtInnerJoin, lDetail, lCondition);
lMasterSource := lDetail;
end;
end;
except
on E: Exception do
begin
lSelect.Free;
E.RaiseOuterException(EAqInternal.Create('It wasn''t possible to build the select for the ' +
pClass.QualifiedClassName + ' class.'));
end;
end;
Result := lSelect;
end;
function TAqDBORMManager.BuildBaseUpdates(const pClass: TClass): IAqResultList<IAqDBSQLUpdate>;
var
lORM: TAqDBORM;
lUpdates: TAqResultList<IAqDBSQLUpdate>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lUpdates := TAqResultList<IAqDBSQLUpdate>.Create;
try
lUpdates.Add(TAqDBSQLUpdate.Create(lORM.MainTable.Name));
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
lUpdates.Add(TAqDBSQLUpdate.Create(lSpecialization.Name));
end;
end;
except
lUpdates.Free;
raise;
end;
Result := lUpdates;
end;
function TAqDBORMManager.BuildDeletes(const pClass: TClass): IAqResultList<IAqDBSQLDelete>;
var
lORM: TAqDBORM;
lDeletes: TAqResultList<IAqDBSQLDelete>;
lPKs: TAqList<TAqDBORMColumn>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
lFirstCondition: TAqDBSQLComparisonCondition;
lComposedCondition: TAqDBSQLComposedCondition;
function CreateCondition(const pColumnName: string): TAqDBSQLComparisonCondition;
begin
Result := TAqDBSQLComparisonCondition.Create(TAqDBSQLColumn.Create(pColumnName),
TAqDBSQLComparison.cpEqual, TAqDBSQLParameter.Create(pColumnName));
end;
procedure AddCondition(const pColumnName: string);
begin
if not Assigned(lFirstCondition) then
begin
lFirstCondition := CreateCondition(pColumnName);
end else begin
if not Assigned(lComposedCondition) then
begin
lComposedCondition := TAqDBSQLComposedCondition.Create(lFirstCondition);
end;
lComposedCondition.AddCondition(TAqDBSQLBooleanOperator.boAnd, CreateCondition(pColumnName));
end;
end;
procedure AddDelete(pTable: TAqDBORMTable<AqTable>);
var
lColumn: TAqDBORMColumn;
lDelete: IAqDBSQLDelete;
begin
lFirstCondition := nil;
lComposedCondition := nil;
lDelete := TAqDBSQLDelete.Create(pTable.Name);
if TAqDBTableMappingProperty.tmpInheritPKs in pTable.Attribute.MappingProperties then
begin
for lColumn in lPKs do
begin
AddCondition(lColumn.Name);
end;
end;
for lColumn in pTable.Columns do
begin
if Assigned(lColumn.Attribute) and (lColumn.Attribute.PrimaryKey) then
begin
AddCondition(lColumn.Name);
lPKs.Add(lColumn);
end;
end;
if Assigned(lComposedCondition) then
begin
lDelete.Condition := lComposedCondition;
end else if Assigned(lFirstCondition) then
begin
lDelete.Condition := lFirstCondition;
end;
lDeletes.Insert(0, lDelete);
end;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lDeletes := TAqResultList<IAqDBSQLDelete>.Create;
try
lPKs := TAqList<TAqDBORMColumn>.Create;
try
AddDelete(lORM.MainTable);
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
AddDelete(TAqDBORMTable<AqTable>(lSpecialization));
end;
end;
finally
lPKs.Free;
end;
except
lDeletes.Free;
raise;
end;
Result := lDeletes;
end;
function TAqDBORMManager.BuildInserts(const pClass: TClass): IAqResultList<IAqDBSQLInsert>;
var
lORM: TAqDBORM;
lInserts: TAqResultList<IAqDBSQLInsert>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
lPKs: TAqList<TAqDBORMColumn>;
lAutoIncrementType: TAqDBAutoIncrementType;
procedure AddInsert(const pTable: TAqDBORMTable<AqTable>);
var
lInsert: IAqDBSQLInsert;
lColumn: TAqDBORMColumn;
begin
lInsert := TAqDBSQLInsert.Create(pTable.Name);
if TAqDBTableMappingProperty.tmpInheritPKs in pTable.Attribute.MappingProperties then
begin
for lColumn in lPKs do
begin
lInsert.AddAssignment(TAqDBSQLColumn.Create(lColumn.Name), TAqDBSQLParameter.Create(lColumn.Name));
end;
end;
for lColumn in pTable.Columns do
begin
if Assigned(lColumn.Attribute) and (lColumn.Attribute.PrimaryKey) then
begin
lPKs.Add(lColumn);
end;
if (lAutoIncrementType = TAqDBAutoIncrementType.aiGenerator) or not Assigned(lColumn.Attribute) or not
lColumn.Attribute.AutoIncrement then
begin
lInsert.AddAssignment(TAqDBSQLColumn.Create(lColumn.Name), TAqDBSQLParameter.Create(lColumn.Name));
end;
end;
lInserts.Add(lInsert);
end;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lInserts := TAqResultList<IAqDBSQLInsert>.Create;
try
lAutoIncrementType := Adapter.AutoIncrementType;
lPKs := TAqList<TAqDBORMColumn>.Create;
try
AddInsert(lORM.MainTable);
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
AddInsert(TAqDBORMTable<AqTable>(lSpecialization));
end;
end;
finally
lPKs.Free;
end;
except
lInserts.Free;
raise;
end;
Result := lInserts;
end;
function TAqDBORMManager.BuildSelect(const pClass: TClass): IAqDBSQLSelect;
var
lORM: TAqDBORM;
lI: Int32;
procedure AddColumns(const pORMTable: TAqDBORMTable; const pSource: IAqDBSQLSource);
var
lColumn: TAqDBORMColumn;
begin
for lColumn in pORMTable.Columns do
begin
Result.AddColumn(lColumn.Name, lColumn.Alias, pSource);
end;
end;
begin
Result := BuildBaseSelect(pClass);
lORM := TAqDBORMReader.GetORM(pClass);
AddColumns(lORM.MainTable, Result.Source);
if lORM.HasSpecializations then
begin
for lI := 0 to lORM.Specializations.Count - 1 do
begin
AddColumns(lORM.Specializations[lI], Result.Joins[lI].Source);
end;
end;
end;
function TAqDBORMManager.BuildUpdates(const pClass: TClass): IAqResultList<IAqDBSQLUpdate>;
var
lORM: TAqDBORM;
lUpdates: TAqResultList<IAqDBSQLUpdate>;
lPKs: TAqList<TAqDBORMColumn>;
lSpecialization: TAqDBORMTable<AqSpecialization>;
lFirstCondition: TAqDBSQLComparisonCondition;
lComposedCondition: TAqDBSQLComposedCondition;
function CreateCondition(const pColumnName: string): TAqDBSQLComparisonCondition;
begin
Result := TAqDBSQLComparisonCondition.Create(TAqDBSQLColumn.Create(pColumnName),
TAqDBSQLComparison.cpEqual, TAqDBSQLParameter.Create(pColumnName));
end;
procedure AddCondition(const pColumnName: string);
begin
if not Assigned(lFirstCondition) then
begin
lFirstCondition := CreateCondition(pColumnName);
end else begin
if not Assigned(lComposedCondition) then
begin
lComposedCondition := TAqDBSQLComposedCondition.Create(lFirstCondition);
end;
lComposedCondition.AddCondition(TAqDBSQLBooleanOperator.boAnd, CreateCondition(pColumnName));
end;
end;
procedure AddUpdate(pTable: TAqDBORMTable<AqTable>);
var
lColumn: TAqDBORMColumn;
lUpdate: IAqDBSQLUpdate;
begin
lFirstCondition := nil;
lComposedCondition := nil;
lUpdate := TAqDBSQLUpdate.Create(pTable.Name);
if TAqDBTableMappingProperty.tmpInheritPKs in pTable.Attribute.MappingProperties then
begin
for lColumn in lPKs do
begin
AddCondition(lColumn.Name);
end;
end;
for lColumn in pTable.Columns do
begin
if Assigned(lColumn.Attribute) and (lColumn.Attribute.PrimaryKey) then
begin
AddCondition(lColumn.Name);
lPKs.Add(lColumn);
end else begin
lUpdate.AddAssignment(TAqDBSQLColumn.Create(lColumn.Name), TAqDBSQLParameter.Create(lColumn.Name));
end;
end;
if Assigned(lComposedCondition) then
begin
lUpdate.Condition := lComposedCondition;
end else if Assigned(lFirstCondition) then
begin
lUpdate.Condition := lFirstCondition;
end;
lUpdates.Add(lUpdate);
end;
begin
lORM := TAqDBORMReader.GetORM(pClass);
lUpdates := TAqResultList<IAqDBSQLUpdate>.Create;
try
lPKs := TAqList<TAqDBORMColumn>.Create;
try
AddUpdate(lORM.MainTable);
if lORM.HasSpecializations then
begin
for lSpecialization in lORM.Specializations do
begin
AddUpdate(TAqDBORMTable<AqTable>(lSpecialization));
end;
end;
finally
lPKs.Free;
end;
except
lUpdates.Free;
raise;
end;
Result := lUpdates;
end;
function TAqDBORMManager.ExecuteWithObject(const pSQLCommand: string; const pObject: TObject): Int64;
begin
if Assigned(pObject) then
begin
Result := FConnection.ExecuteCommand(pSQLCommand,
procedure(pParameters: IAqDBParameters)
begin
FillParametersWithObjectValues(pParameters, pObject);
end);
end else begin
Result := FConnection.ExecuteCommand(pSQLCommand);
end;
end;
function TAqDBORMManager.Get<T>(pSelect: IAqDBSQLSelect): IAqResultList<T>;
begin
if not Get<T>(pSelect, Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.Get<T>: IAqResultList<T>;
begin
if not Get<T>(Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.Get<T>(pFilter: IAqDBSQLComposedCondition; out pResultList: IAqResultList<T>): Boolean;
var
lSelect: IAqDBSQLSelect;
begin
lSelect := BuildSelect(T);
lSelect.CustomizeCondition(pFilter);
Result := Get<T>(lSelect, pResultList);
end;
function TAqDBORMManager.Get<T>(pSelect: string): IAqResultList<T>;
begin
if not Get<T>(pSelect, Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.Get<T>(pFilter: IAqDBSQLComposedCondition): IAqResultList<T>;
begin
if not Get<T>(pFilter, Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.GetByID<T>(const pID: Int64): T;
begin
if not GetByID<T>(pID, Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.GetClient<T>: T;
var
lClient: TAqDBORMManagerClient;
begin
FClients.Lock;
try
if not FClients.TryGetValue(T.QualifiedClassName, lClient) then
begin
lClient := T.CreateNew(Self);
FClients.Add(T.QualifiedClassName, lClient);
end;
Result := T(lClient);
finally
FClients.Release;
end;
end;
function TAqDBORMManager.GetSQLSolver: TAqDBSQLSolver;
begin
Result := nil;
try
Result := Adapter.SQLSolver;
if not Assigned(Result) then
begin
raise EAqInternal.Create('The manager''s adapter has no SQL solver.');
end;
except
on E: Exception do
begin
E.RaiseOuterException(EAqInternal.Create('It wasn''t possible to obtain the SQL solver.'));
end;
end;
end;
function TAqDBORMManager.GetByID<T>(const pID: Int64; out pResult: T): Boolean;
var
lPKs: IAqResultList<TAqDBORMColumn>;
lResultList: IAqResultList<T>;
begin
lPKs := TAqDBORMReader.GetORM(T).GetPrimaryKeys;
if (lPKs.Count <> 1) or not (lPKs.First.&Type in adtIntTypes) then
begin
raise EAqInternal.Create('The class ' + T.QualifiedClassName + ' doesn''t observe the Unique Key rule.');
end;
Result := Get<T>(CreateFilter.AddColumnEqual(lPKs.First.Name, pID), lResultList);
if Result then
begin
pResult := lResultList.Extract;
end;
end;
function TAqDBORMManager.Get<T>(const pCustomizationMethod: TProc<IAqDBSQLSelect>;
out pResultList: IAqResultList<T>): Boolean;
var
lSelect: IAqDBSQLSelect;
begin
lSelect := BuildSelect(T);
if Assigned(pCustomizationMethod) then
begin
pCustomizationMethod(lSelect);
end;
Result := Get<T>(lSelect, pResultList);
end;
function TAqDBORMManager.Get<T>(const pCustomizationMethod: TProc<IAqDBSQLSelect>): IAqResultList<T>;
begin
if not Get<T>(pCustomizationMethod, Result) then
begin
Result := nil;
end;
end;
function TAqDBORMManager.GetAdapter: TAqDBAdapter;
begin
Result := nil;
try
if not Assigned(FConnection) then
begin
raise EAqInternal.Create('The ORM manager has no connection associated.');
end;
Result := FConnection.Adapter;
if not Assigned(Result) then
begin
raise EAqInternal.Create('The manager''s connection has no adapter.');
end;
except
on E: Exception do
begin
E.RaiseOuterException(EAqInternal.Create('It wasn''t possible to get the Adapter.'));
end;
end;
end;
{ TAqDBORMManagerClient }
procedure TAqDBORMManagerClient.CommitTransaction;
begin
FORMManager.Connection.CommitTransaction;
end;
constructor TAqDBORMManagerClient.Create;
begin
end;
class function TAqDBORMManagerClient.CreateNew(const pORMManager: TAqDBORMManager): TAqDBORMManagerClient;
begin
Result := Self.Create;
Result.FORMManager := pORMManager;
end;
procedure TAqDBORMManagerClient.RollbackTransaction;
begin
FORMManager.Connection.RollbackTransaction;
end;
procedure TAqDBORMManagerClient.StartTransaction;
begin
FORMManager.Connection.StartTransaction;
end;
end.
|
(*
Category: SWAG Title: PRINTING/PRINTER MANAGEMENT ROUTINES
Original name: 0027.PAS
Description: Printusing in PASCAL
Author: PHIL NICKELL
Date: 11-21-93 09:45
*)
{
From: PHIL NICKELL
Subj: Basic PrintUsing in PAS
Does anyone know of any shareware or freeware routines in Turbo Pascal
5.5, that will allow me to format numbers or strings like the PRINTUSING
statement in BASIC???
}
PROCEDURE printusing (mask: string; value:real);
{ Calling syntax = PRINTUSING(mask, number)
mask can be a string label or a literal
Example printusing('#,###,###',45.63);
printusing('######.###,value); }
const
comma : char = ',';
point : char = '.';
minussign : char = '-';
var
fieldwidth, integerlength, i, j, places, pointposition: integer;
usingcommas, decimal, negative : boolean;
outstring, integerstring : string;
begin
negative := ( value < 0 );
value := abs( value );
places := 0;
fieldwidth := length( mask );
usingcommas := ( pos ( comma, mask ) > 0 );
decimal := ( pos (point,mask) > 0 );
if decimal then
begin
pointposition := pos(point, mask);
places := fieldwidth - pointposition;
END;
str ( value:0:places, outstring );
if usingcommas then
begin
J := 0;
integerstring :=
copy (outstring, 1, length(outstring)-places);
integerlength := length(integerstring);
if decimal then
integerlength := pred(integerlength);
for i := integerlength downto 2 do
begin
inc(j);
if j mod 3 = 0 then
insert (comma,outstring,i);
end;
end;
if negative then
outstring := minussign + outstring;
write( outstring:fieldwidth);
END; {PRINTUSING}
BEGIN
PrintUsing('##,###,###.##',123456.78);
END.
|
//////////////////////////////////////////////////////////////////////////
// This file is a part of NotLimited.Framework.Common NuGet package.
// You are strongly discouraged from fiddling with it.
// If you do, all hell will break loose and living will envy the dead.
//////////////////////////////////////////////////////////////////////////
using System.Threading.Tasks;
namespace NotLimited.Framework.Common.Helpers
{
public static class TaskHelpers
{
public static void MuteExceptions(this Task task)
{
if (task.Exception != null)
task.Exception.Handle(x => true);
}
}
} |
unit UGameText;
interface
uses
w3system;
type
TText = class(TObject)
text, colour : string;
x, y : integer;
constructor create(newText, newColour : string; newX, newY : integer);
end;
implementation
constructor TText.create(newText, newColour : string; newX, newY : integer);
begin
text := newText;
x := newX;
y := newY;
colour := newColour;
end;
end. |
unit VertexQueue;
interface
uses BasicMathsTypes;
type
PVertexData = ^TVertexData;
TVertexData = record
X,Y,Z : integer;
Position: integer;
Next : PVertexData;
end;
CVertexQueue = class
private
Start,Last : PVertexData;
NumItems: integer;
procedure Reset;
public
// Constructors and Destructors
constructor Create;
destructor Destroy; override;
// Add
procedure Add (_x,_y,_z,_Position : integer);
procedure Delete(var _item: PVertexData);
// Delete
procedure Clear;
// Gets
function IsEmpty: boolean;
function GetNumItems: integer;
function GetVector3i(const _item: PVertexData): TVector3i;
// Misc
function GetFirstElement: PVertexData;
function GetLastElement: PVertexData;
end;
implementation
constructor CVertexQueue.Create;
begin
Reset;
end;
destructor CVertexQueue.Destroy;
begin
Clear;
inherited Destroy;
end;
procedure CVertexQueue.Reset;
begin
Start := nil;
Last := nil;
NumItems := 0;
end;
// Add
procedure CVertexQueue.Add (_x,_y,_z,_Position : integer);
var
NewPosition : PVertexData;
begin
New(NewPosition);
NewPosition^.x := _x;
NewPosition^.y := _y;
NewPosition^.z := _z;
NewPosition^.Position := _Position;
NewPosition^.Next := nil;
if Start <> nil then
begin
Last^.Next := NewPosition;
end
else
begin
Start := NewPosition;
end;
Last := NewPosition;
inc(NumItems);
end;
// Delete
procedure CVertexQueue.Delete(var _item: PVertexData);
var
Previous : PVertexData;
begin
if _Item <> nil then
begin
Previous := Start;
if _Item = Start then
begin
Start := Start^.Next;
end
else
begin
while Previous^.Next <> _Item do
begin
Previous := Previous^.Next;
end;
Previous^.Next := _Item^.Next;
if _Item = Last then
begin
Last := Previous;
end;
end;
Dispose(_Item);
dec(NumItems);
end;
end;
procedure CVertexQueue.Clear;
var
Item,Garbage : PVertexData;
begin
Item := Start;
while Item <> nil do
begin
Garbage := Item;
Item := Item^.Next;
dispose(Garbage);
end;
end;
// Gets
function CVertexQueue.IsEmpty: boolean;
begin
Result := (Start = nil);
end;
function CVertexQueue.GetNumItems: integer;
begin
Result := NumItems;
end;
function CVertexQueue.GetVector3i(const _item: PVertexData): TVector3i;
begin
if _Item <> nil then
begin
Result.X := _Item^.X;
Result.Y := _Item^.Y;
Result.Z := _Item^.Z;
end
else
begin
Result.X := 0;
Result.Y := 0;
Result.Z := 0;
end;
end;
// Misc
function CVertexQueue.GetFirstElement: PVertexData;
begin
Result := Start;
end;
function CVertexQueue.GetLastElement: PVertexData;
begin
Result := Last;
end;
end.
|
unit Antlr.Runtime.Tools.Tests;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
SysUtils,
TestFramework,
Generics.Defaults,
Generics.Collections,
Antlr.Runtime.Tools;
type
// Test methods for class IANTLRString
TestIANTLRString = class(TTestCase)
strict private
FIANTLRString: IANTLRString;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestGetValue;
procedure TestSetValue;
end;
// Test methods for class TANTLRString
TestTANTLRString = class(TTestCase)
strict private
FANTLRString: TANTLRString;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestToString;
end;
// Test methods for class ICloneable
TestICloneable = class(TTestCase)
strict private
FICloneable: ICloneable;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestClone;
end;
// Test methods for class IList
TestIList = class(TTestCase)
strict private
FIList: IList<Integer>;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestGetCapacity;
procedure TestSetCapacity;
procedure TestGetCount;
procedure TestSetCount;
procedure TestGetItem;
procedure TestSetItem;
procedure TestAdd;
procedure TestAddRange;
procedure TestInsert;
procedure TestRemove;
procedure TestDelete;
procedure TestDeleteRange;
procedure TestClear;
procedure TestContains;
procedure TestIndexOf;
end;
// Test methods for class IDictionary
TestIDictionary = class(TTestCase)
strict private
FIDictionary: IDictionary<String, Integer>;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestGetItem;
procedure TestSetItem;
procedure TestGetCount;
procedure TestAdd;
procedure TestRemove;
procedure TestTryGetValue;
procedure TestContainsKey;
procedure TestContainsValue;
procedure TestEnumeration;
end;
// Test methods for record TLocalStorage
TestTLocalStorage = class(TTestCase)
published
procedure TestLocalIntegerStorage;
procedure TestLocalInterfaceStorage;
end;
implementation
type
IFoo = interface(IANTLRInterface)
['{48E3FC72-4E63-46D8-8450-A561ECF76995}']
function GetValue: String;
procedure SetValue(const V: String);
property Value: String read GetValue write SetValue;
end;
TFoo = class(TANTLRObject, ICloneable, IFoo)
FValue: String;
function GetValue: String;
procedure SetValue(const V: String);
function Clone: IANTLRInterface;
end;
function TFoo.GetValue: String;
begin
Result := FValue;
end;
procedure TFoo.SetValue(const V: String);
begin
FValue := V;
end;
function TFoo.Clone: IANTLRInterface;
var
Foo: IFoo;
begin
Foo := TFoo.Create;
Foo.Value := FValue;
Result := Foo;
end;
procedure TestIANTLRString.SetUp;
begin
FIANTLRString := TANTLRString.Create('foo');
end;
procedure TestIANTLRString.TearDown;
begin
FIANTLRString := nil;
end;
procedure TestIANTLRString.TestGetValue;
var
ReturnValue: string;
begin
ReturnValue := FIANTLRString.GetValue;
CheckEquals(ReturnValue,'foo');
end;
procedure TestIANTLRString.TestSetValue;
var
Value: string;
begin
Value := 'bar';
FIANTLRString.SetValue(Value);
CheckEquals(FIANTLRString.Value,'bar');
end;
procedure TestTANTLRString.SetUp;
begin
FANTLRString := TANTLRString.Create('foo');
end;
procedure TestTANTLRString.TearDown;
begin
FANTLRString.Free;
FANTLRString := nil;
end;
procedure TestTANTLRString.TestToString;
var
ReturnValue: string;
begin
ReturnValue := FANTLRString.ToString;
CheckEquals(ReturnValue,'foo');
end;
procedure TestICloneable.SetUp;
var
Foo: IFoo;
begin
Foo := TFoo.Create;
Foo.Value := 'original';
FICloneable := Foo as ICloneable;
end;
procedure TestICloneable.TearDown;
begin
FICloneable := nil;
end;
procedure TestICloneable.TestClone;
var
ReturnValue: IANTLRInterface;
begin
ReturnValue := FICloneable.Clone;
Check(Supports(ReturnValue, IFoo));
CheckEquals((ReturnValue as IFoo).Value,(FICloneable as IFoo).Value);
end;
procedure TestIList.SetUp;
begin
FIList := TList<Integer>.Create;
end;
procedure TestIList.TearDown;
begin
FIList := nil;
end;
procedure TestIList.TestGetCapacity;
var
ReturnValue: Integer;
begin
FIList.Capacity := 100;
ReturnValue := FIList.GetCapacity;
CheckEquals(ReturnValue,100);
end;
procedure TestIList.TestSetCapacity;
var
Value: Integer;
begin
Value := 100;
FIList.SetCapacity(Value);
CheckEquals(FIList.Capacity,100);
end;
procedure TestIList.TestGetCount;
var
ReturnValue: Integer;
begin
FIList.Clear;
FIList.Add(123);
ReturnValue := FIList.GetCount;
CheckEquals(ReturnValue,1);
end;
procedure TestIList.TestSetCount;
var
Value: Integer;
begin
Value := 4;
FIList.SetCount(Value);
CheckEquals(FIList.Count,4);
end;
procedure TestIList.TestGetItem;
var
ReturnValue: Integer;
Index: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Index := 2;
ReturnValue := FIList.GetItem(Index);
CheckEquals(ReturnValue,300);
end;
procedure TestIList.TestSetItem;
var
Value: Integer;
Index: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Index := 3;
Value := 333;
FIList.SetItem(Index, Value);
CheckEquals(FIList.Items[3],333);
end;
procedure TestIList.TestAdd;
var
ReturnValue: Integer;
Value: Integer;
begin
FIList.Clear;
Value := 3;
ReturnValue := FIList.Add(Value);
CheckEquals(ReturnValue,0);
end;
procedure TestIList.TestAddRange;
var
Values: array [0..3] of Integer;
begin
FIList.Clear;
Values[0] := 111;
Values[1] := 222;
Values[2] := 333;
Values[3] := 444;
FIList.AddRange(Values);
CheckEquals(FIList[0],111);
CheckEquals(FIList[1],222);
CheckEquals(FIList[2],333);
CheckEquals(FIList[3],444);
end;
procedure TestIList.TestInsert;
var
Value: Integer;
Index: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Index := 2;
Value := 250;
FIList.Insert(Index, Value);
CheckEquals(FIList[1],200);
CheckEquals(FIList[2],250);
CheckEquals(FIList[3],300);
end;
procedure TestIList.TestRemove;
var
ReturnValue: Integer;
Value: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Value := 300;
ReturnValue := FIList.Remove(Value);
CheckEquals(ReturnValue,2);
end;
procedure TestIList.TestDelete;
var
Index: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Index := 2;
FIList.Delete(Index);
CheckEquals(FIList[2],400);
end;
procedure TestIList.TestDeleteRange;
var
ACount: Integer;
AIndex: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
AIndex := 1;
ACount := 2;
FIList.DeleteRange(AIndex, ACount);
CheckEquals(FIlist[0],100);
CheckEquals(FIlist[1],400);
end;
procedure TestIList.TestClear;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
FIList.Clear;
CheckEquals(FIList.Count,0);
end;
procedure TestIList.TestContains;
var
ReturnValue: Boolean;
Value: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Value := 200;
ReturnValue := FIList.Contains(Value);
CheckTrue(ReturnValue);
Value := 250;
ReturnValue := FIList.Contains(Value);
CheckFalse(ReturnValue);
end;
procedure TestIList.TestIndexOf;
var
ReturnValue: Integer;
Value: Integer;
begin
FIList.Clear;
FIList.Add(100);
FIList.Add(200);
FIList.Add(300);
FIList.Add(400);
Value := 300;
ReturnValue := FIList.IndexOf(Value);
CheckEquals(ReturnValue,2);
Value := 301;
ReturnValue := FIList.IndexOf(Value);
CheckEquals(ReturnValue,-1);
end;
procedure TestIDictionary.SetUp;
begin
FIDictionary := TDictionary<String, Integer>.Create;
FIDictionary.Add('Foo',1);
FIDictionary.Add('Bar',3);
FIDictionary.Add('Baz',7);
FIDictionary.Add('Zip',7);
end;
procedure TestIDictionary.TearDown;
begin
FIDictionary := nil;
end;
procedure TestIDictionary.TestGetItem;
var
ReturnValue: Integer;
Key: String;
begin
Key := 'Baz';
ReturnValue := FIDictionary.GetItem(Key);
CheckEquals(ReturnValue,7);
end;
procedure TestIDictionary.TestSetItem;
var
Value: Integer;
Key: String;
begin
Key := 'Bar';
Value := 20;
FIDictionary.SetItem(Key, Value);
CheckEquals(FIDictionary['Bar'],20);
end;
procedure TestIDictionary.TestGetCount;
var
ReturnValue: Integer;
begin
ReturnValue := FIDictionary.GetCount;
CheckEquals(ReturnValue,4);
end;
procedure TestIDictionary.TestAdd;
var
Value: Integer;
Key: String;
begin
Key := 'Key';
Value := -1;
FIDictionary.Add(Key, Value);
CheckEquals(FIDictionary['Key'],-1);
end;
procedure TestIDictionary.TestRemove;
var
Key: String;
begin
Key := 'Bar';
FIDictionary.Remove(Key);
CheckEquals(FIDictionary.Count,3);
end;
procedure TestIDictionary.TestTryGetValue;
var
ReturnValue: Boolean;
Value: Integer;
Key: String;
begin
Key := 'Zip';
ReturnValue := FIDictionary.TryGetValue(Key, Value);
CheckTrue(ReturnValue);
CheckEquals(Value,7);
Key := 'Oops';
ReturnValue := FIDictionary.TryGetValue(Key, Value);
CheckFalse(ReturnValue);
end;
procedure TestIDictionary.TestContainsKey;
var
ReturnValue: Boolean;
Key: String;
begin
Key := 'Foo';
ReturnValue := FIDictionary.ContainsKey(Key);
CheckTrue(ReturnValue);
Key := 'foo';
ReturnValue := FIDictionary.ContainsKey(Key);
CheckFalse(ReturnValue);
end;
procedure TestIDictionary.TestContainsValue;
var
ReturnValue: Boolean;
Value: Integer;
begin
Value := 3;
ReturnValue := FIDictionary.ContainsValue(Value);
CheckTrue(ReturnValue);
Value := 2;
ReturnValue := FIDictionary.ContainsValue(Value);
CheckFalse(ReturnValue);
end;
procedure TestIDictionary.TestEnumeration;
var
Pair: TPair<String, Integer>;
Foo, Bar, Baz, Zip: Boolean;
begin
Foo := False;
Bar := False;
Baz := False;
Zip := False;
for Pair in FIDictionary do
begin
if (Pair.Key = 'Foo') then
begin
Foo := True;
CheckEquals(Pair.Value, 1);
end
else
if (Pair.Key = 'Bar') then
begin
Bar := True;
CheckEquals(Pair.Value, 3);
end
else
if (Pair.Key = 'Baz') then
begin
Baz := True;
CheckEquals(Pair.Value, 7);
end
else
if (Pair.Key = 'Zip') then
begin
Zip := True;
CheckEquals(Pair.Value, 7);
end
else
Check(False, 'Unknown key in dictionary');
end;
CheckTrue(Foo);
CheckTrue(Bar);
CheckTrue(Baz);
CheckTrue(Zip);
end;
{ TestTLocalStorage }
procedure TestTLocalStorage.TestLocalIntegerStorage;
var
Locals: TLocalStorage;
begin
Locals.Initialize;
try
Locals.AsInteger['x'] := 2;
Locals.AsInteger['X'] := 3;
CheckEquals(2, Locals.AsInteger['x']);
CheckEquals(3, Locals.AsInteger['X']);
CheckEquals(0, Locals.AsInteger['y']);
Locals.AsInteger['X'] := Locals.AsInteger['x'] * 2;
CheckEquals(4, Locals.AsInteger['X']);
CheckEquals(2, Locals.Count);
finally
Locals.Finalize;
end;
end;
procedure TestTLocalStorage.TestLocalInterfaceStorage;
var
Locals: TLocalStorage;
begin
Locals.Initialize;
try
{ Local variable Z is never accessed again. We add it to check that there
will be no memory leak. }
Locals['Z'] := TANTLRString.Create('Value Z');
Locals['x'] := TANTLRString.Create('Value x');
Locals['X'] := TANTLRString.Create('Value X');
CheckEquals('Value x', (Locals['x'] as IANTLRString).Value);
CheckEquals('Value X', (Locals['X'] as IANTLRString).Value);
Check(Locals['y'] = nil);
Locals['X'] := TANTLRString.Create(
(Locals['X'] as IANTLRString).Value + ' Update');
CheckEquals('Value X Update', (Locals['X'] as IANTLRString).Value);
CheckEquals(3, Locals.Count);
finally
Locals.Finalize;
end;
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestIANTLRString.Suite);
RegisterTest(TestTANTLRString.Suite);
RegisterTest(TestICloneable.Suite);
RegisterTest(TestIList.Suite);
RegisterTest(TestIDictionary.Suite);
RegisterTest(TestTLocalStorage.Suite);
end.
|
unit System_Hdc;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, ExtCtrls, Graphics;
type
{ TSystemHdc }
TSystemHdc = class
private // Attribute
const
// Konstante für die Anzahl an Bytes / Sektor
SECBYTES = 512;
// Konstanten der Bit-Adressen im HDC-Error Register
AMNF = 0; // indicates the data address mark has not been found after finding the correct ID field.
TK0NF = 1; // indicates track 0 has not been found during the command.
ABRT = 2; // indicates the requested command has been aborted due to a
// drive status error (such as not ready or write fault) or because
// the command is invalid.
MCR = 3; // these bit is reserved for removable-media drives.
IDNF = 4; // indicates the requested sector’s ID field could not be found.
MC = 5; // these bit is reserved for removable-media drives.
UNC = 6; // indicates an uncorrectable data error has been encountered.
BBK = 7; // indicates a bad block mark was detected in the ID field of the requested sector.
// Konstanten der Bit-Adressen im HDC-Status Register
ERR = 0; // is the error bit. It is set to 1 when the previous command ended
// in some type of error. The other bits in the Status register, and
// the bits in the Error register, have more information as to the
// cause of the error. This bit is set to 0 when a new command is
// serviced.
IDX = 1; // is the index bit. This bit usually contains a 0, except once per
// disc revolution when it is toggled from 0 to 1 and back to 0.
CORR = 2; // is the corrected data bit. It is set to 1 when a correctable data
// error has been encountered and the data has been corrected.
// This condition does not end a multisector read operation. This
// bit is set to 0 when a new command is serviced.
DRQ = 3; // is the data request bit. It is set to 1 when the drive is ready to
// transfer a word or byte of data between the host and the data
// port. The drive is busy whenever DRQ or BSY bits are set to 1.
// When the DRQ bit is set to 1, the host may read or write any of
// the registers including the Command register.
DSC = 4; // is the drive seek complete bit. It is set to 1 when the disc drive is not seeking.
DWF = 5; // is the drive write fault bit. When there is a write fault error, this
// bit is set to 1 and is not changed until the Status register is read
// by the host, at which time the bit again indicates the current write
// fault status.
DRDY = 6; // is the drive ready indicator bit. This bit is set to 0 at power up and
// remains set at 0 until the drive is ready to accept a command.
BSY = 7; // is the busy bit. It is set to 1 whenever the drive has access to the
// command block. When it is set to 1:
// •No other bits are valid.
// •The host is locked out of reading shared registers; the Status register is read instead.
// The BSY bit is set to 1 under the following circumstances:
// • At the assertion of the RESET– signal on the interface
// • At the assertion of the SRST bit in the Device Control register
// • Immediately upon host write to the Command register
// Konstanten der Bit-Adressen im HDC-Drive/Head Register
DRV = 4; // is the bit used to select the drive. Master is 0. Slave is 1.
LBA = 6; // signifies the addressing scheme currently being used. If this bit
// is set to 1, the drive is using the logical block addressing scheme.
// If the bit is set to 0, the CHS scheme is used.
HEAD = 15; // is the 4-bit address used to select the head. When the drive is
// executing the Initialize Drive Parameters command, HEAD
// specifies the maximum head address.
type
TBitReg8 = bitpacked record
case byte of
0: (Value: byte); // 8Bit Register Value
2: (bit: bitpacked array[0..7] of boolean); // Bit Data
end;
Treg16 = packed record
case byte of
0: (Value: word); // 16Bit Register
1: (low: byte; // lower 8Bit
high: byte); // upper 8Bit
end;
Treg32 = packed record
case byte of
0: (Value: dword); // 32Bit Register
1: (low: Treg16; // lower 16Bit
high: Treg16); // upper 16Bit
end;
TDataMode = (SECTOR_READ, SECTOR_WRITE, BUFFER_READ, BUFFER_WRITE, ID_READ);
THardDriveData = record
Heads: byte;
Tracks: word;
Sectors: byte;
Size: dword;
Ready: boolean;
HddStatus: TPanel;
end;
var
dataBuffer: array[0..SECBYTES - 1] of byte;
dataCount: dword;
dataMode: TDataMode;
timerHddStatus: TTimer;
hardDrive: THardDriveData;
hddData: file;
hdcDataHigh: byte;
hdcTrack: Treg16;
hdcSector: byte;
hdcSectorCount: word;
hdcDriveHead: TBitReg8;
hdcFeatures: byte;
hdcStatus: TBitReg8;
hdcError: TBitReg8;
hdcLba: Treg32;
enable8BitDataTransfer: boolean;
protected // Attribute
public // Attribute
public // Konstruktor/Destruktor
constructor Create(var panel: TPanel);
destructor Destroy; override;
private // Methode
procedure calcLbaValue;
procedure calcChsValues;
function calcHddSize: string;
procedure setFeatures;
procedure prepareReadSectors;
procedure prepareReadBuffer;
procedure prepareIdentifyDrive;
procedure finishReadData;
procedure prepareWriteSectors;
procedure prepareWriteBuffer;
procedure finishWriteData;
procedure setHddOffState(Sender: TObject);
procedure setHddReadState;
procedure setHddWriteState;
protected // Methoden
public // Methoden
procedure doReset;
procedure setHddHeads(heads: byte);
procedure setHddTracks(tracks: word);
procedure setHddSectors(sectors: byte);
procedure setHddImage(fileName: string);
procedure setDataLow(Value: byte);
procedure setDataHigh(Value: byte);
procedure setTrackLow(Value: byte);
procedure setTrackHigh(Value: byte);
procedure setSector(Value: byte);
procedure setSectorCount(Value: byte);
procedure setDriveHead(Value: byte);
procedure setCommand(Value: byte);
procedure setFeatures(Value: byte);
function getDataLow: byte;
function getDataHigh: byte;
function getTrackLow: byte;
function getTrackHigh: byte;
function getSector: byte;
function getSectorCount: byte;
function getDriveHead: byte;
function getStatus: byte;
function getError: byte;
end;
var
SystemHdc: TSystemHdc;
implementation
{ TSystemHdc }
uses System_Settings;
// --------------------------------------------------------------------------------
constructor TSystemHdc.Create(var panel: TPanel);
var
ImageFile: string;
begin
inherited Create;
timerHddStatus := TTimer.Create(nil);
timerHddStatus.Enabled := False;
timerHddStatus.Interval := 30;
timerHddStatus.OnTimer := @setHddOffState;
hardDrive.Ready := False;
hardDrive.HddStatus := panel;
setHddHeads(SystemSettings.ReadInteger('Hdd', 'Heads', 16));
setHddTracks(SystemSettings.ReadInteger('Hdd', 'Tracks', 246));
setHddSectors(SystemSettings.ReadInteger('Hdd', 'Sectors', 63));
ImageFile := SystemSettings.ReadString('Hdd', 'ImageFile', '');
if ((ImageFile <> '') and (not FileExists(ImageFile))) then begin
SystemSettings.WriteString('Hdd', 'ImageFile', '');
ImageFile := '';
end;
setHddImage(ImageFile);
doReset;
end;
// --------------------------------------------------------------------------------
destructor TSystemHdc.Destroy;
begin
if Assigned(timerHddStatus) then begin
timerHddStatus.Enabled := False;
timerHddStatus.OnTimer := nil;
timerHddStatus.Destroy;
end;
inherited Destroy;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.calcLbaValue;
begin
if (hdcDriveHead.bit[LBA]) then begin
hdcLba.low.low := hdcSector; // 0..7
hdcLba.low.high := hdcTrack.low; // 8..15
hdcLba.high.low := hdcTrack.high; // 16..23
hdcLba.high.high := (hdcDriveHead.Value and HEAD); // 24..27
end
else begin
hdcLba.Value := ((((hdcTrack.Value * hardDrive.Heads) + (hdcDriveHead.Value and HEAD)) * hardDrive.Sectors) + (hdcSector - 1));
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.calcChsValues;
var
tmpValue: dword;
begin
if (hdcDriveHead.bit[LBA]) then begin
hdcSector := hdcLba.low.low; // 0..7
hdcTrack.low := hdcLba.low.high; // 8..15
hdcTrack.high := hdcLba.high.low; // 16..23
hdcDriveHead.Value := ((hdcDriveHead.Value and not $0F) or (hdcLba.high.high and $0F)); // 24..27
end
else begin
hdcTrack.Value := (hdcLba.Value div (hardDrive.Heads * hardDrive.Sectors));
tmpValue := (hdcLba.Value mod (hardDrive.Heads * hardDrive.Sectors));
hdcDriveHead.Value := ((hdcDriveHead.Value and not $0F) or ((tmpValue div hardDrive.Sectors) and $0F));
hdcSector := (((tmpValue mod hardDrive.Sectors) + 1) and $FF);
end;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.calcHddSize: string;
var
sizeString: string;
begin
if ((hardDrive.Size div 1048576) > 0) then begin
sizeString := FloatToStrF((hardDrive.Size / 1048576), ffNumber, 15, 2) + 'MB';
end
else if ((hardDrive.Size div 1024) > 0) then begin
sizeString := FloatToStrF((hardDrive.Size / 1024), ffNumber, 15, 2) + 'KB';
end
else begin
sizeString := IntToStr(hardDrive.Size) + 'Byte';
end;
Result := sizeString;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setFeatures;
var
abort: boolean;
begin
hdcStatus.bit[BSY] := True;
hdcStatus.bit[ERR] := False;
abort := False;
if (not hdcDriveHead.bit[DRV]) then begin
case (hdcFeatures) of
$01: enable8BitDataTransfer := True;
$81: enable8BitDataTransfer := False;
else abort := True;
end;
end
else begin
abort := True;
end;
hdcError.bit[ABRT] := abort;
hdcStatus.bit[ERR] := abort;
hdcStatus.bit[BSY] := False;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.prepareReadSectors;
begin
hdcStatus.bit[BSY] := True;
hdcStatus.bit[DSC] := False;
calcLbaValue;
if (hdcSectorCount = 0) then begin
hdcSectorCount := 256;
end;
if (((hdcLba.Value * SECBYTES) = (hardDrive.Size - SECBYTES)) or (hardDrive.Size = 0) or (hdcSector > hardDrive.Sectors) or
(hdcTrack.Value >= hardDrive.Tracks) or (hdcDriveHead.bit[DRV]) or ((hdcDriveHead.Value and HEAD) > hardDrive.Heads)) then begin
hdcStatus.bit[ERR] := True;
hdcError.bit[IDNF] := True;
end;
try
Reset(hddData, SECBYTES);
Seek(hddData, hdcLba.Value);
BlockRead(hddData, dataBuffer[0], 1);
CloseFile(hddData);
hdcStatus.bit[DSC] := True;
hdcStatus.bit[DRQ] := True;
dataCount := 0;
dataMode := SECTOR_READ;
setHddReadState;
timerHddStatus.Enabled := True;
except
hdcStatus.bit[ERR] := True;
hdcError.bit[AMNF] := True;
hdcStatus.bit[BSY] := False;
end;
hdcStatus.bit[BSY] := False;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.prepareReadBuffer;
begin
hdcStatus.bit[BSY] := False;
hdcStatus.bit[DRQ] := True;
dataCount := 0;
dataMode := BUFFER_READ;
setHddReadState;
timerHddStatus.Enabled := True;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.prepareIdentifyDrive;
var
index: word;
idword: Treg16;
iddoubleword: Treg32;
begin
hdcStatus.bit[BSY] := False;
hdcStatus.bit[DRQ] := True;
dataCount := 0;
for index := 0 to SECBYTES - 1 do begin
dataBuffer[index] := 0;
end;
dataBuffer[0] := %01000000; // fixed drive
dataBuffer[1] := %00000100; // disk transfer rate > 10 Mbs
idword.Value := hardDrive.Tracks; // Number of cylinders
dataBuffer[2] := idword.low;
dataBuffer[3] := idword.high;
idword.Value := hardDrive.Heads; // Number of heads
dataBuffer[6] := idword.low;
dataBuffer[7] := idword.high;
idword.Value := (SECBYTES * hardDrive.Sectors); // Number of unformatted bytes per track
dataBuffer[8] := idword.low;
dataBuffer[9] := idword.high;
idword.Value := SECBYTES; // Number of unformatted bytes per sector
dataBuffer[10] := idword.low;
dataBuffer[11] := idword.high;
idword.Value := hardDrive.Sectors; // Number of sectors per track
dataBuffer[12] := idword.low;
dataBuffer[13] := idword.high;
idword.Value := 1; // Buffer size in 512 byte increments
dataBuffer[42] := idword.low;
dataBuffer[43] := idword.high;
dataBuffer[49] := %00000000; // Vendor unique
dataBuffer[50] := %00000010; // LBA supported
idword.Value := hardDrive.Tracks; // Number of current cylinders
dataBuffer[108] := idword.low;
dataBuffer[109] := idword.high;
idword.Value := hardDrive.Heads; // Number of current heads
dataBuffer[110] := idword.low;
dataBuffer[111] := idword.high;
idword.Value := hardDrive.Sectors; // Number of current sectors per track
dataBuffer[112] := idword.low;
dataBuffer[113] := idword.high;
iddoubleword.Value := (hardDrive.Tracks * hardDrive.Sectors * hardDrive.Heads); // Current capacity in sectors
dataBuffer[114] := iddoubleword.low.low;
dataBuffer[115] := iddoubleword.low.high;
dataBuffer[116] := iddoubleword.high.low;
dataBuffer[117] := iddoubleword.high.high;
iddoubleword.Value := (hardDrive.Tracks * hardDrive.Sectors * hardDrive.Heads); // Total number of user addressable sectors (LBA mode only)
dataBuffer[120] := iddoubleword.low.low;
dataBuffer[121] := iddoubleword.low.high;
dataBuffer[122] := iddoubleword.high.low;
dataBuffer[123] := iddoubleword.high.high;
dataMode := ID_READ;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.finishReadData;
begin
hdcStatus.bit[DRQ] := False;
case (dataMode) of
SECTOR_READ: begin
Dec(hdcSectorCount);
if (hdcSectorCount > 0) then begin
Inc(hdcLba.Value);
calcChsValues;
prepareReadSectors;
end;
end;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.prepareWriteSectors;
begin
hdcStatus.bit[BSY] := True;
hdcStatus.bit[DSC] := False;
calcLbaValue;
if (hdcSectorCount = 0) then begin
hdcSectorCount := 256;
end;
if (((hdcLba.Value * SECBYTES) = (hardDrive.Size - SECBYTES)) or (hardDrive.Size = 0) or (hdcSector > hardDrive.Sectors) or
(hdcTrack.Value >= hardDrive.Tracks) or (hdcDriveHead.bit[DRV]) or ((hdcDriveHead.Value and HEAD) > hardDrive.Heads)) then begin
hdcStatus.bit[ERR] := True;
hdcError.bit[IDNF] := True;
end;
hdcStatus.bit[DSC] := True;
hdcStatus.bit[BSY] := False;
hdcStatus.bit[DRQ] := True;
dataCount := 0;
dataMode := SECTOR_WRITE;
setHddWriteState;
timerHddStatus.Enabled := True;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.prepareWriteBuffer;
begin
hdcStatus.bit[BSY] := False;
hdcStatus.bit[DRQ] := True;
dataCount := 0;
dataMode := BUFFER_WRITE;
setHddWriteState;
timerHddStatus.Enabled := True;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.finishWriteData;
begin
hdcStatus.bit[DRQ] := False;
case (dataMode) of
SECTOR_WRITE: begin
try
Reset(hddData, SECBYTES);
Seek(hddData, hdcLba.Value);
BlockWrite(hddData, dataBuffer[0], 1);
CloseFile(hddData);
Dec(hdcSectorCount);
if (hdcSectorCount > 0) then begin
Inc(hdcLba.Value);
calcChsValues;
prepareWriteSectors;
end;
except
hdcStatus.bit[ERR] := True;
hdcError.bit[AMNF] := True;
hdcStatus.bit[BSY] := False;
end;
end;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddOffState(Sender: TObject);
begin
timerHddStatus.Enabled := False;
with hardDrive.HddStatus do begin
Canvas.Brush.Style := bsSolid;
Canvas.Brush.Color := clDefault;
Canvas.Pen.Style := psClear;
Canvas.Pen.Color := clDefault;
Canvas.Pen.Width := 2;
Canvas.Ellipse(19, 0, 30, 10);
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddReadState;
begin
timerHddStatus.Enabled := False;
with hardDrive.HddStatus do begin
Canvas.Brush.Style := bsSolid;
Canvas.Brush.Color := clLime;
Canvas.Pen.Style := psSolid;
Canvas.Pen.Color := clGreen;
Canvas.Pen.Width := 1;
Canvas.Ellipse(20, 1, 28, 9);
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddWriteState;
begin
timerHddStatus.Enabled := False;
with hardDrive.HddStatus do begin
Canvas.Brush.Style := bsSolid;
Canvas.Brush.Color := clRed;
Canvas.Pen.Style := psSolid;
Canvas.Pen.Color := clMaroon;
Canvas.Pen.Width := 1;
Canvas.Ellipse(20, 1, 28, 9);
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.doReset;
begin
hdcError.Value := $01;
hdcStatus.Value := $00;
hdcSector := $01;
hdcSectorCount := $01;
hdcTrack.low := $00;
hdcTrack.high := $00;
hdcDriveHead.Value := $00;
hdcStatus.bit[DRDY] := hardDrive.Ready;
hdcStatus.bit[BSY] := not hardDrive.Ready;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddHeads(heads: byte);
var
bit: integer;
begin
for bit := 0 to 8 do begin
if ((1 shl bit) >= heads) then
break;
end;
hardDrive.Heads := (1 shl bit);
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddTracks(tracks: word);
begin
hardDrive.Tracks := tracks;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddSectors(sectors: byte);
begin
hardDrive.Sectors := sectors;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setHddImage(fileName: string);
var
hintString: string;
begin
hardDrive.Ready := False;
hintString := '';
if (FileExists(FileName)) then begin
try
AssignFile(hddData, FileName);
Reset(hddData, 1);
hardDrive.Size := FileSize(hddData);
hintString := 'Image: ' + ExtractFileName(fileName) + LineEnding + 'Größe: ' + calcHddSize + LineEnding +
'Köpfe: ' + IntToStr(hardDrive.Heads) + LineEnding + 'Spuren: ' + IntToStr(hardDrive.Tracks) +
LineEnding + 'Sektoren: ' + IntToStr(hardDrive.Sectors) + LineEnding + 'Bytes/Sektor: ' + IntToStr(SECBYTES);
hardDrive.Ready := True;
Close(hddData);
except;
end;
end
else begin
hardDrive.Size := 0;
end;
hardDrive.HddStatus.Hint := hintString;
hdcStatus.bit[DRDY] := hardDrive.Ready;
hdcStatus.bit[DSC] := hardDrive.Ready;
hdcStatus.bit[BSY] := not hardDrive.Ready;
hardDrive.HddStatus.Enabled := hardDrive.Ready;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setDataLow(Value: byte);
begin
dataBuffer[dataCount] := Value;
Inc(dataCount);
if (not enable8BitDataTransfer) then begin
dataBuffer[dataCount] := hdcDataHigh;
Inc(dataCount);
end;
if (dataCount >= SECBYTES) then begin
finishWriteData;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setDataHigh(Value: byte);
begin
hdcDataHigh := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setTrackLow(Value: byte);
begin
hdcTrack.low := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setTrackHigh(Value: byte);
begin
hdcTrack.high := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setSector(Value: byte);
begin
hdcSector := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setSectorCount(Value: byte);
begin
hdcSectorCount := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setDriveHead(Value: byte);
begin
hdcDriveHead.Value := Value;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setCommand(Value: byte);
begin
hdcError.Value := 0;
hdcStatus.bit[ERR] := False;
hdcStatus.bit[DRDY] := hardDrive.HddStatus.Enabled;
hdcStatus.bit[BSY] := not hdcStatus.bit[DRDY];
case (Value) of
$00: begin // NOP
hdcStatus.bit[ERR] := True;
hdcStatus.bit[DSC] := True;
hdcError.bit[ABRT] := True;
hdcStatus.bit[BSY] := False;
end;
$10..$1F: begin // Recalibrate
hdcTrack.Value := 0;
hdcError.Value := 0;
hdcStatus.bit[DSC] := True;
hdcStatus.bit[BSY] := False;
end;
$20..$21: begin // Read Sectors
prepareReadSectors;
end;
$30..$31: begin // Write Sectors
prepareWriteSectors;
end;
$E4: begin // Read Buffer
prepareReadBuffer;
end;
$E8: begin // Write Buffer
prepareWriteBuffer;
end;
$EC: begin // Identify Drive
prepareIdentifyDrive;
end;
$EF: begin // Set Feature
setFeatures;
end;
else begin
hdcStatus.bit[ERR] := True;
hdcStatus.bit[BSY] := False;
hdcError.bit[ABRT] := True;
end;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemHdc.setFeatures(Value: byte);
begin
hdcFeatures := Value;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getDataLow: byte;
begin
Result := dataBuffer[dataCount];
Inc(dataCount);
if (not enable8BitDataTransfer) then begin
hdcDataHigh := dataBuffer[dataCount];
Inc(dataCount);
end;
if (dataCount >= SECBYTES) then begin
finishReadData;
end;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getDataHigh: byte;
begin
Result := hdcDataHigh;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getTrackLow: byte;
begin
Result := hdcTrack.low;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getTrackHigh: byte;
begin
Result := hdcTrack.high;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getSector: byte;
begin
Result := hdcSector;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getSectorCount: byte;
begin
Result := hdcSectorCount;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getDriveHead: byte;
begin
Result := hdcDriveHead.Value;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getStatus: byte;
begin
Result := hdcStatus.Value;
end;
// --------------------------------------------------------------------------------
function TSystemHdc.getError: byte;
begin
Result := hdcError.Value;
end;
// --------------------------------------------------------------------------------
end.
|
type coordinates = array[1..3] of real;
var x, y : coordinates;
var i : integer;
function distance(x1, y1, x2, y2 : real) : real;
begin
distance := sqrt(sqr(x1 - x2) + sqr(y1 - y2));
end;
function area(a, b ,c : real) : real;
var p : real;
begin
p := (a + b + c) / 2;
area := sqrt(p*(p - a)*(p - b)*(p - c));
end;
begin
for i := 1 to 3 do
begin
readln(x[i]);
readln(y[i]);
end;
writeln
(
area
(
distance(x[1], y[1], x[2], y[2]),
distance(x[2], y[2], x[3], y[3]),
distance(x[1], y[1], x[3], y[3])
)
);
end.
|
unit gr_OperationEnd_MainForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxLookAndFeelPainters, cxLabel, cxTextEdit, cxMaskEdit,
cxSpinEdit, ExtCtrls, cxControls, cxContainer, cxEdit, cxProgressBar,
StdCtrls, cxButtons, ActnList, FIBQuery, pFIBQuery, pFIBStoredProc,
FIBDatabase, pFIBDatabase, DB, FIBDataSet, pFIBDataSet, iBase,
zProc, zMessages, Unit_zGlobal_Consts, dxBar, dxBarExtItems, cxStyles,
cxCustomData, cxGraphics, cxFilter, cxData, cxDataStorage, cxDBData,
cxGridCustomTableView, cxGridTableView, cxGridDBTableView, cxGridLevel,
cxClasses, cxGridCustomView, cxGrid, cxGridBandedTableView, PackageLoad,
Dates, gr_uWaitForm, gr_uMessage, gr_uCommonConsts, gr_uCommonProc,
cxGroupBox;
type
TFgrOperationEnd = class(TForm)
DB: TpFIBDatabase;
WriteTransaction: TpFIBTransaction;
StProc: TpFIBStoredProc;
GroupBox: TcxGroupBox;
SaveBtn: TcxButton;
DelBtn: TcxButton;
CancelBtn: TcxButton;
cxLabel1: TcxLabel;
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure SaveBtnClick(Sender: TObject);
procedure DelBtnClick(Sender: TObject);
procedure CancelBtnClick(Sender: TObject);
private
POwner:TComponent;
PDB_handle:TISC_DB_HANDLE;
PLanguageIndex:Byte;
PIsRollback:boolean;
public
constructor Create(AOwner:TComponent;ADB_Handle:TISC_DB_HANDLE;IsRollback:boolean);reintroduce;
end;
implementation
uses DateUtils;
{$R *.dfm}
constructor TFgrOperationEnd.Create(AOwner:TComponent;ADB_Handle:TISC_DB_HANDLE;IsRollback:boolean);
var kod_action:variant;
begin
inherited Create(AOwner);
PDB_handle := ADB_Handle;
PLanguageIndex := IndexLanguage;
DB.Handle:=ADB_Handle;
POwner:=AOwner;
//------------------------------------------------------------------------------
self.Caption:=OperationEnd_Text[PLanguageIndex];
SaveBtn.Caption:=SaveBtn_Caption[PLanguageIndex];
CancelBtn.Caption:=CancelBtn_Caption[PLanguageIndex];
DelBtn.Caption:=DeleteBtn_Caption[PLanguageIndex];
PIsRollback:=IsRollback;
if PIsRollback
then
cxLabel1.Caption:='Увага! ви хочете відкотити систему у попередній період?'
else
begin
kod_action:=ValueFieldZSetup(DB.Handle,'GR_KOD_ACTION');
if kod_action<>null then
begin
if kod_action=11 then
begin
cxLabel1.Style.Font.Size:=8;
cxLabel1.Caption:='Увага! Ви хочете зберехти розрахунок стипендії та перевести систему у наступниій період?'
end
else
begin
if kod_action=14 then
cxLabel1.Caption:='Увага! Ви хочете зберехти перерахунок?'
else
cxLabel1.Caption:='Увага! Ви хочете зберехти розрахунок?';
end
end
else cxLabel1.Caption:='Увага! Ви хочете зберехти розрахунок?';
end;
if pIsRollback then
begin
DelBtn.Caption:='Відкотити';
DelBtn.Left:=SaveBtn.Left;
SaveBtn.Visible:=False;
end;
end;
procedure TFgrOperationEnd.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
if WriteTransaction.InTransaction then WriteTransaction.Commit;
end;
procedure TFgrOperationEnd.SaveBtnClick(Sender: TObject);
var
wf:TForm;
begin
try
wf:=ShowWaitForm(TForm(POwner),wfPrepareData);
StProc.Transaction.StartTransaction;
StProc.StoredProcName:='GR_PAYMENT_COUNT_OPERATION_END';
StProc.Prepare;
StProc.ParamByName('IS_DELETE').AsString :='F';
StProc.ExecProc;
StProc.Transaction.Commit;
except
on E:Exception do
begin
CloseWaitForm(wf);
grShowMessage(ECaption[PlanguageIndex],e.Message,mtError,[mbOK]);
StProc.Transaction.Rollback;
end;
end;
CloseWaitForm(wf);
grSetBeginAction(DB.Handle,0);
grShowMessage('Вдале завершення', 'Розрахунок збережений!', mtInformation,[mbOk]);
ModalResult:=mrYes
end;
procedure TFgrOperationEnd.DelBtnClick(Sender: TObject);
var
wf:TForm;
begin
try
wf:=ShowWaitForm(TForm(POwner),wfPrepareData);
StProc.Transaction.StartTransaction;
StProc.StoredProcName:='GR_PAYMENT_COUNT_OPERATION_END';
StProc.Prepare;
if PIsRollback then
StProc.ParamByName('IS_DELETE').AsString :='O'
else
StProc.ParamByName('IS_DELETE').AsString :='T';
StProc.ExecProc;
StProc.Transaction.Commit;
except
on E:Exception do
begin
CloseWaitForm(wf);
grShowMessage(ECaption[PlanguageIndex],e.Message,mtError,[mbOK]);
StProc.Transaction.Rollback;
end;
end;
CloseWaitForm(wf);
grSetBeginAction(DB.Handle,0);
if PIsRollback then
grShowMessage('Вдале завершення','Відкат системи завершено!',mtInformation,[mbOk])
else
grShowMessage('Вдале завершення','Розрахунок вилучено!',mtInformation,[mbOk]);
ModalResult:=mrNo;
end;
procedure TFgrOperationEnd.CancelBtnClick(Sender: TObject);
begin
ModalResult:=mrCancel;
end;
end.
|
namespace WindowsLive;
interface
uses
System,
System.Collections,
System.Collections.Generic,
System.Collections.Specialized,
System.IO,
System.Net,
System.Reflection,
System.Security.Cryptography,
System.Text,
System.Text.RegularExpressions,
System.Web,
System.Web.Configuration,
System.Xml;
type
WindowsLiveLogin = public class
private
m_AppId: String;
m_SecurityAlgorithm: String;
m_cyrptKey: Array of Byte;
m_signKey: Array of Byte;
m_BaseUrl: String;
m_SecureUrl: String;
method GetAppId: String;
method SetAppId(AValue: String);
method SetSecret(AValue: String);
method GetSecurityAlgorithm: String;
method GetBaseUrl: String;
method GetSecureUrl: String;
class method debug(AMsg: string);
class method parseSettings(ASettingsFile: String): NameValueCollection;
class method derive(ASecret: String; APrefix: String): Array of Byte;
class method getTimeStamp: String;
class method e64(Ab: array of Byte): String;
class method u64(AStr: String): Array of Byte;
class method fetch(AUrl: String): String;
public
constructor(AAppId: String; ASecret: String);
constructor(AAppId: String; ASecret: String; ASecurityAlgorithm: String);
constructor(ALoadAppSettings: Boolean);
constructor(ASettingsFile: String);
public
method ProcessLogin(AQuery: NameValueCollection): User;
method GetLoginUrl: String;
method GetLoginUrl(AContext: String): String;
method GetLogoutUrl: String;
method ProcessToken(AToken: String): User;
method ProcessToken(AToken: String; AContext: String): User;
method GetClearCookieResponse(out AType: String;
out AContent: Array of Byte);
method DecodeToken(AToken: String): String;
method SignToken(AToken: String): Array of Byte;
method ValidateToken(AToken: String): String;
method GetAppVerifier: String;
method GetAppVerifier(AIp: String): String;
method GetAppLoginUrl: String;
method GetAppLoginUrl(ASiteId: String): String;
method GetAppLoginUrl(ASiteId: String; AIp: String): String;
method GetAppLoginUrl(ASiteId: String; AIp: String; AJs: Boolean): String;
method GetAppSecurityToken: String;
method GetAppSecurityToken(ASiteId: String): String;
method GetAppSecurityToken(ASiteId: String; AIp: String): String;
method GetAppRetCode: String;
method GetTrustedParams(AUser: String): NameValueCollection;
method GetTrustedParams(AUser: String; ARetCode: String): NameValueCollection;
method GetTrustedToken(AUser: String): String;
method GetTrustedLoginUrl: String;
method GetTrustedLogoutUrl: String;
public
property AppId: String read GetAppId write SetAppId;
property Secret: String write SetSecret;
property SecurityAlgorithm: String
read GetSecurityAlgorithm
write m_SecurityAlgorithm;
property BaseUrl: String read GetBaseUrl write m_BaseUrl;
property SecureUrl: String read GetSecureUrl write m_SecureUrl;
end;
/// <summary>
/// Holds the user information after a successful login.
/// </summary>
User nested in WindowsLiveLogin = public class
private
m_id: String;
m_timestamp: DateTime;
method setId(AId: String);
method setTimestamp(ATimestamp: String);
method setFlags(AFlags: String);
public
constructor(ATimestamp: String; AId: String; AFlags: String;
AContext: String; AToken: String);
property Token: String;
property Context: String;
property UsePersistentCookie: Boolean;
property Id: String read m_id write setId;
property Timestamp: DateTime read m_timestamp;
end;
implementation
/// <summary>
/// Initialize the WindowsLiveLogin module with the
/// application ID and secret key.
///
/// We recommend that you employ strong measures to protect
/// the secret key. The secret key should never be
/// exposed to the Web or other users.
/// </summary>
constructor WindowsLiveLogin(AAppId: String; ASecret: String);
begin
constructor(AAppId, ASecret, nil);
end;
/// <summary>
/// Initialize the WindowsLiveLogin module with the
/// application ID, secret key, and security algorithm to use.
///
/// We recommend that you employ strong measures to protect
/// the secret key. The secret key should never be
/// exposed to the Web or other users.
/// </summary>
constructor WindowsLiveLogin(AAppId: String; ASecret: String; ASecurityAlgorithm: String);
begin
AppId := AAppId;
Secret := ASecret;
SecurityAlgorithm := ASecurityAlgorithm;
end;
/// <summary>
/// Initialize the WindowsLiveLogin module from the
/// web.config file if loadAppSettings is true. Otherwise,
/// you will have to manually set the AppId, Secret and
/// SecurityAlgorithm properties.
/// </summary>
constructor WindowsLiveLogin(ALoadAppSettings : Boolean);
begin
if not ALoadAppSettings then
exit;
var l_appSettings := WebConfigurationManager.AppSettings;
if l_appSettings = nil then
begin
raise new IOException('Error: WindowsLiveLogin: Failed to load the Web '
+ 'application settings.');
end;
AppId := l_appSettings['wll_appid'];
Secret := l_appSettings['wll_secret'];
SecurityAlgorithm := l_appSettings['wll_securityalgorithm'];
BaseUrl := l_appSettings['wll_baseurl'];
SecureUrl := l_appSettings['wll_secureurl'];
end;
/// <summary>
/// Stub implementation for logging debug output. You can run
/// a tool such as 'dbmon' to see the output.
/// </summary>
class method WindowsLiveLogin.debug(AMsg: string);
begin
System.Diagnostics.Debug.WriteLine(AMsg);
System.Diagnostics.Debug.Flush;
end;
/// <summary><![CDATA[
/// Initialize the WindowsLiveLogin module from a settings file.
///
/// 'settingsFile' specifies the location of the XML settings
/// file containing the application ID, secret key, and an optional
/// security algorithm. The file is of the following format:
///
/// <windowslivelogin>
/// <appid>APPID</appid>
/// <secret>SECRET</secret>
/// <securityalgorithm>wsignin1.0</securityalgorithm>
/// </windowslivelogin>
///
/// We recommend that you store the Windows Live Login settings file
/// in an area on your server that cannot be accessed through
/// the Internet. This file contains important confidential
/// information.
/// ]]></summary>
constructor WindowsLiveLogin(ASettingsFile: String);
begin
var l_settings := parseSettings(ASettingsFile);
AppId := l_settings['appid'];
Secret := l_settings['secret'];
SecurityAlgorithm := l_settings['securityalgorithm'];
BaseUrl := l_settings['baseurl'];
SecureUrl := l_settings['secureurl'];
end;
method WindowsLiveLogin.GetAppId: String;
begin
if (m_AppId = nil) or (m_AppId.Length = 0) then
begin
raise new InvalidOperationException('Error: AppId: Application ID was '
+ 'not set. Aborting.');
end;
result := m_AppId;
end;
method WindowsLiveLogin.SetAppId(AValue: String);
begin
if (AValue = nil) or (AValue.Length = 0) then
begin
raise new ArgumentNullException('AValue');
end;
var l_re: Regex := new Regex('^\w+$');
if not l_re.IsMatch(AValue) then
begin
raise new ArgumentException('Error: AppId: Application ID must be '
+ 'alphanumeric: "' + AValue + '"');
end;
m_AppId := AValue;
end;
method WindowsLiveLogin.SetSecret(AValue: String);
begin
if (AValue = nil) or (AValue.Length = 0) then
begin
raise new ArgumentNullException('AValue');
end;
if AValue.Length < 16 then
begin
raise new ArgumentException('Error: Secret: Secret key is expected '
+ 'to be longer than 16 characters: "' + AValue.Length + '"');
end;
m_cyrptKey := derive(AValue, 'ENCRYPTION');
m_signKey := derive(AValue, 'SIGNATURE');
end;
method WindowsLiveLogin.GetSecurityAlgorithm: String;
begin
if (m_SecurityAlgorithm = nil) or (m_SecurityAlgorithm.Length = 0) then
begin
result := 'wsignin1.0';
exit;
end;
result := m_SecurityAlgorithm;
end;
method WindowsLiveLogin.GetBaseUrl: String;
begin
if (m_BaseUrl = nil) or (m_BaseUrl.Length = 0) then
begin
result := 'http://login.live.com/';
exit;
end;
result := m_BaseUrl;
end;
method WindowsLiveLogin.GetSecureUrl: String;
begin
if (m_SecureUrl = nil) or (m_SecureUrl.Length = 0) then
begin
result := 'https://login.live.com/';
exit;
end;
result := m_SecureUrl;
end;
class method WindowsLiveLogin.parseSettings(ASettingsFile: String): NameValueCollection;
begin
if ASettingsFile = nil then
begin
raise new ArgumentNullException('ASettingsFile');
end;
result := new NameValueCollection;
//*** Throws an exception on any failure
var xd := new XmlDocument;
xd.Load(ASettingsFile);
// application id
var appIdNode := xd.SelectSingleNode('//windowslivelogin/appid');
var l_appId := appIdNode:InnerText;
if (l_appId = nil) or (l_appId.Length = 0) then
begin
raise new XmlException('Error: parseSettings: Could not read '
+ '"appid" node in settings file: "' + ASettingsFile + "'");
end;
result['appid'] := l_appId;
// secret
var secretNode := xd.SelectSingleNode('//windowslivelogin/secret');
var l_secret := secretNode:InnerText;
if (l_secret = nil) or (l_secret.Length = 0) then
begin
raise new XmlException('Error: parseSettings: Could not read '
+ '"secret" node in settings file: "' + ASettingsFile + "'");
end;
result['secret'] := l_secret;
// security algorithm
var secalgoNode := xd.SelectSingleNode('//windowslivelogin/securityalgorithm');
result['securityalgorithm'] := secalgoNode:InnerText;
// base url
var baseurlNode := xd.SelectSingleNode('//windowslivelogin/baseurl');
result['baseurl'] := baseurlNode:InnerText;
// secure url
var securlNode := xd.SelectSingleNode('//windowslivelogin/secureurl');
result['secureurl'] := securlNode:InnerText;
end;
/// <summary>
/// Processes the login response from the Windows Live Login server.
/// </summary>
///
/// <param name="query">Contains the preprocessed POST query
/// such as that returned by HttpRequest.Form</param>
///
/// <returns>The method returns a User object on successful
/// sign-in; otherwise null.</returns>
method WindowsLiveLogin.ProcessLogin(AQuery: NameValueCollection): User;
begin
result := nil;
if (AQuery = nil) then
begin
debug('Error: ProcessLogin: Invalid Query');
exit;
end;
var l_action := AQuery['action'];
if l_action <> 'login' then
begin
debug('Warning: ProcessLogin: query action ignored: "' + l_action + '"');
exit;
end;
var l_token := AQuery['stoken'];
var l_context := AQuery['appctx'];
if (l_context <> nil) then
begin
l_context := HttpUtility.UrlDecode(l_context);
end;
result := ProcessToken(l_token, l_context);
end;
/// <summary>
/// Returns the sign-in URL to use for the Windows Live Login server.
/// We recommend that you use the Sign In control instead.
/// </summary>
/// <returns>Sign-in URL</returns>
method WindowsLiveLogin.GetLoginUrl: String;
begin
result := GetLoginUrl(nil);
end;
/// <summary>
/// Returns the sign-in URL to use for the Windows Live Login server.
/// We recommend that you use the Sign In control instead.
/// </summary>
/// <param name="context">If you specify it, <paramref
/// name="context"/> will be returned as-is in the login
/// response for site-specific use.</param>
/// <returns>Sign-in URL</returns>
method WindowsLiveLogin.GetLoginUrl(AContext: String): String;
begin
var l_algPart := '&alg=' + SecurityAlgorithm;
var l_contextPart :=
iif(AContext = nil, String.Empty, '&appctx=' + HttpUtility.UrlEncode(AContext));
result := BaseUrl + 'wlogin.srf?appid=' + AppId + l_algPart + l_contextPart;
end;
/// <summary>
/// Returns the sign-out URL to use for the Windows Live Login server.
/// We recommend that you use the Sign In control instead.
/// </summary>
/// <returns>Sign-out URL</returns>
method WindowsLiveLogin.GetLogoutUrl: String;
begin
result := BaseUrl + 'logout.srf?appid=' + AppId;
end;
/// <summary>
/// Decodes and validates a Web Authentication token. Returns a User
/// object on success.
/// </summary>
method WindowsLiveLogin.ProcessToken(AToken: String): User;
begin
result := ProcessToken(AToken, nil);
end;
/// <summary>
/// Decodes and validates a Web Authentication token. Returns a User
/// object on success. If a context is passed in, it will be
/// returned as the context field in the User object.
/// </summary>
method WindowsLiveLogin.ProcessToken(AToken: String; AContext: String): User;
begin
result := nil;
if (AToken = nil) or (AToken.Length = 0) then
begin
debug('Error: ProcessToken: Invalid token');
exit;
end;
var l_token := DecodeToken(AToken);
if (l_token = nil) or (l_token.Length = 0) then
begin
debug('Error: ProcessToken: Failed to decode token: "' + AToken + '"');
exit;
end;
l_token := ValidateToken(l_token);
if (l_token = nil) or (l_token.Length = 0) then
begin
debug('Error: ProcessToken: Failed to validate token: "' + AToken + '"');
end;
var l_parsedToken := HttpUtility.ParseQueryString(l_token);
if (l_parsedToken = nil) or (l_parsedToken.Count < 3) then
begin
debug('Error: ProcessToken: Failed to parse token after decoding: "'
+ AToken + '"');
exit;
end;
var l_user: User := nil;
try
l_user := new User(l_parsedToken['ts'], l_parsedToken['uid'],
l_parsedToken['flags'], AContext, AToken);
except
on E: Exception do
begin
debug('Error: ProcessToken: Contents of Token considered '
+ 'innvalid: "' + E + '"');
end;
end;
result := l_user;
end;
/// <summary>
/// When a user signs out of Windows Live or a Windows Live
/// application, a best-effort attempt is made to sign the user out
/// from all other Windows Live applications the user might be signed
/// in to. This is done by calling the handler page for each
/// application with 'action' parameter set to 'clearcookie' in the query
/// string. The application handler is then responsible for clearing
/// any cookies or data associated with the login. After successfully
/// signing the user out, the handler should return a GIF (any
/// GIF) as response to the action=clearcookie query.
///
/// This function returns an appropriate content type and body
/// response that the application handler can return to
/// signify a successful sign-out from the application.
/// </summary>
method WindowsLiveLogin.GetClearCookieResponse(out AType: String;
out AContent: Array of Byte);
const cGif = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAEALAAAAAABAAEAAAIBTAA7';
begin
AType := 'image/gif';
AContent := Convert.FromBase64String(cGif);
end;
/// <summary>
/// Decode the given token. Returns null on failure.
/// </summary>
///
/// <list type="number">
/// <item>First, the string is URL unescaped and base64
/// decoded.</item>
/// <item>Second, the IV is extracted from the first 16 bytes
/// of the string.</item>
/// <item>Finally, the string is decrypted by using the
/// encryption key.</item>
/// </list>
method WindowsLiveLogin.DecodeToken(AToken: String): String;
begin
result := nil;
if (m_cyrptKey = nil) or (m_cyrptKey.Length = 0) then
begin
raise new InvalidOperationException('Error: DecodeToken: Secret key '
+ 'was not set. Aborting');
end;
var l_ivLength := 16;
var l_ivAndEncryptedValue: array of Byte := u64(AToken);
if (l_ivAndEncryptedValue = nil) or
(l_ivAndEncryptedValue.Length <= l_ivLength) or
((l_ivAndEncryptedValue.Length mod l_ivLength) <> 0) then
begin
debug('Error: DecodeToken: Attempted to decode invalid token');
exit;
end;
var l_aesAlg: Rijndael := nil;
var l_memStream: MemoryStream := nil;
var l_cStream: CryptoStream := nil;
var l_sReader: StreamReader := nil;
var l_decodedValue: String := nil;
try
l_aesAlg := new RijndaelManaged;
l_aesAlg.KeySize := 128;
l_aesAlg.Key := m_cyrptKey;
l_aesAlg.Padding := PaddingMode.PKCS7;
l_memStream := new MemoryStream(l_ivAndEncryptedValue);
var l_iv := new array of Byte(l_ivLength);
l_memStream.Read(l_iv, 0, l_ivLength);
l_aesAlg.IV := l_iv;
l_cStream := new CryptoStream(l_memStream,
l_aesAlg.CreateDecryptor, CryptoStreamMode.Read);
l_sReader := new StreamReader(l_cStream, Encoding.ASCII);
l_decodedValue := l_sReader.ReadToEnd;
except
on E: Exception do
begin
debug('Error: DecodeToken: Decryption failed: "' + E + '"');
end;
finally
try
if not (l_sReader = nil) then l_sReader.Close;
if not (l_cStream = nil) then l_cStream.Close;
if not (l_memStream = nil) then l_memStream.Close;
if not (l_aesAlg = nil) then l_aesAlg.Clear;
except
on E: Exception do
begin
debug('Error: DecodeToken: Failure during resource cleanup: "' + E + '"');
end;
end;
end;
result := l_decodedValue;
end;
/// <summary>
/// Creates a signature for the given string by using the
/// signature key.
/// </summary>
method WindowsLiveLogin.SignToken(AToken: String): Array of Byte;
begin
result := nil;
if (m_signKey = nil) or (m_signKey.Length = 0) then
begin
raise new InvalidOperationException('Error: SignToken: Secret key was '
+ 'not set. Aborting');
end;
if (AToken = nil) or (AToken.Length = 0) then
begin
debug('Attempted to sign null token.');
exit;
end;
using lhashAlg := new HMACSHA256(m_signKey) do
begin
var l_data := Encoding.Default.GetBytes(AToken);
var l_hash := lhashAlg.ComputeHash(l_data);
result := l_hash;
end;
end;
/// <summary>
/// Extracts the signature from the token and validates it.
/// </summary>
method WindowsLiveLogin.ValidateToken(AToken: String): String;
begin
result := nil;
if (AToken = nil) or (AToken.Length = 0) then
begin
debug('Error: Validate Token: Invalid token.');
exit;
end;
var s: Array of String := [ '&sig=' ];
var l_bodyAndSig: Array of String := AToken.Split(s, StringSplitOptions.None);
if (l_bodyAndSig.Length <> 2) then
begin
debug('Error: ValidateToken: Invalid token: "' + AToken + '"');
exit;
end;
var l_sig: Array of Byte := u64(l_bodyAndSig[1]);
if (l_sig = nil) then
begin
debug('Error: ValidateToken: Could not extract the signature '
+ 'from the token');
exit;
end;
var l_sig2: Array of Byte := SignToken(l_bodyAndSig[0]);
if (l_sig2 = nil) then
begin
debug('Error: ValidateToken: Could not generate a signature '
+ 'from the token');
exit;
end;
if (l_sig.Length = l_sig2.Length) then
begin
for each c in l_sig index i do
begin
if l_sig2[i] <> c then
begin
debug('Error: ValidateToken: Signature did not match.');
exit;
end;
end;
result := AToken;
end;
end;
/// <summary>
/// Generates an Application Verifier token.
/// </summary>
method WindowsLiveLogin.GetAppVerifier: String;
begin
result := GetAppVerifier(nil);
end;
/// <summary>
/// Generates an Application Verifier token. An IP address
/// can be included in the token.
/// </summary>
method WindowsLiveLogin.GetAppVerifier(AIp: String): String;
begin
result := nil;
var l_ipPart := iif(AIp = nil, String.Empty, '&ip=' + AIp);
var l_token := 'appid=' + AppId + '&ts=' + getTimeStamp + l_ipPart;
var l_sig := e64(SignToken(l_token));
if (l_sig = nil) then
begin
debug('Error: GetAppVerifier: Failed to sign the token.');
exit;
end;
l_token := l_token + '&sig=' + l_sig;
result := HttpUtility.UrlEncode(l_token);
end;
/// <summary>
/// Returns the URL needed to retrieve the application
/// security token. The application security token
/// will be generated for the Windows Live site.
///
/// JavaScript Output Notation (JSON) output is returned:
///
/// {"token":"<value>"}
/// </summary>
method WindowsLiveLogin.GetAppLoginUrl: String;
begin
result := GetAppLoginUrl(nil, nil, false);
end;
/// <summary>
/// Returns the URL needed to retrieve the application
/// security token.
///
/// By default, the application security token will be
/// generated for the Windows Live site; a specific Site ID
/// can optionally be specified in 'siteId'.
///
/// JSON output is returned:
///
/// {"token":"<value>"}
/// </summary>
method WindowsLiveLogin.GetAppLoginUrl(ASiteId: String): String;
begin
result := GetAppLoginUrl(ASiteId, nil, false);
end;
method WindowsLiveLogin.GetAppLoginUrl(ASiteId: String; AIp: String): String;
begin
result := GetAppLoginUrl(ASiteId, AIp, false);
end;
/// <summary>
/// Returns the URL needed to retrieve the application
/// security token.
///
/// By default, the application security token will be
/// generated for the Windows Live site; a specific Site ID
/// can optionally be specified in 'siteId'. The IP address
/// can also optionally be included in 'ip'.
///
/// JSON output is returned:
///
/// {"token":"<value>"}
/// </summary>
method WindowsLiveLogin.GetAppLoginUrl(ASiteId: String;
AIp: String; AJs: Boolean): String;
begin
var l_algPart := '&alg=' + SecurityAlgorithm;
var l_sitePart := iif(ASiteId = nil, String.Empty, '&id=' + ASiteId);
var l_jsPart := iif(not AJs, String.Empty, '&js=1');
result := SecureUrl + 'wapplogin.srf?app=' +
GetAppVerifier(AIp) + l_algPart + l_sitePart + l_jsPart;
end;
/// <summary>
/// Retrieves the application security token for application
/// verification from the application login URL. The
/// application security token will be generated for the
/// Windows Live site.
/// </summary>
method WindowsLiveLogin.GetAppSecurityToken: String;
begin
result := GetAppSecurityToken(nil, nil);
end;
/// <summary>
/// Retrieves the application security token for application
/// verification from the application login URL.
///
/// By default, the application security token will be
/// generated for the Windows Live site; a specific Site ID
/// can optionally be specified in 'siteId'.
/// </summary>
method WindowsLiveLogin.GetAppSecurityToken(ASiteId: String): String;
begin
result := GetAppSecurityToken(ASiteId, nil);
end;
/// <summary>
/// Retrieves the application security token for application
/// verification from the application login URL.
///
/// By default, the application security token will be
/// generated for the Windows Live site; a specific Site ID
/// can optionally be specified in 'siteId'. The IP address
/// can also optionally be included in 'ip'.
///
/// Implementation note: The application security token is
/// downloaded from the application login URL in JSON format
/// {"token":"<value>"}, so we need to extract
/// <value> from the string and return it as seen here.
/// </summary>
method WindowsLiveLogin.GetAppSecurityToken(ASiteId: String; AIp: String): String;
begin
result := nil;
var l_url := GetAppLoginUrl(ASiteId, AIp);
var l_body := fetch(l_url);
if (l_body = nil) then
begin
debug('Error: GetAppSecurityToken: Failed to download token.');
exit;
end;
var l_re: Regex := new Regex('{"token":"(.*)"}');
var l_gc: GroupCollection := l_re.Match(l_body).Groups;
if (l_gc.Count <> 2) then
begin
debug('Error: GetAppSecurityToken: Failed to extract token: "' + l_body + '"');
exit;
end;
var l_cc: CaptureCollection := l_gc[1].Captures;
if (l_cc.Count <> 1) then
begin
debug('Error: GetAppSecurityToken: Failed to extract token: "' + l_body + '"');
exit;
end;
result := l_cc[0].ToString;
end;
/// <summary>
/// Returns a string that can be passed to the GetTrustedParams
/// function as the 'retcode' parameter. If this is specified as
/// the 'retcode', then the app will be used as return URL
/// after it finishes trusted login.
/// </summary>
method WindowsLiveLogin.GetAppRetCode: String;
begin
result := 'appid=' + AppId;
end;
/// <summary>
/// Returns a table of key-value pairs that must be posted to
/// the login URL for trusted login. Use HTTP POST to do
/// this. Be aware that the values in the table are neither
/// URL nor HTML escaped and may have to be escaped if you are
/// inserting them in code such as an HTML form.
///
/// The user to be trusted on the local site is passed in as
/// string 'user'.
/// </summary>
method WindowsLiveLogin.GetTrustedParams(AUser: String): NameValueCollection;
begin
result := GetTrustedParams(AUser, nil);
end;
/// <summary>
/// Returns a table of key-value pairs that must be posted to
/// the login URL for trusted login. Use HTTP POST to do
/// this. Be aware that the values in the table are neither
/// URL nor HTML escaped and may have to be escaped if you are
/// inserting them in code such as an HTML form.
///
/// The user to be trusted on the local site is passed in as
/// string 'user'.
///
/// Optionally, 'retcode' specifies the resource to which
/// successful login is redirected, such as Windows Live Mail,
/// and is typically a string in the format 'id=2000'. If you
/// pass in the value from GetAppRetCode instead, login will
/// be redirected to the application. Otherwise, an HTTP 200
/// response is returned.
/// </summary>
method WindowsLiveLogin.GetTrustedParams(AUser: String; ARetCode: String): NameValueCollection;
begin
result := nil;
var l_token := GetTrustedToken(AUser);
if (l_token = nil) then
exit;
l_token := '<wst:RequestSecurityTokenResponse '
+ 'xmlns:wst="http://schemas.xmlsoap.org/ws/2005/02/trust">'
+ '<wst:RequestedSecurityToken>'
+ '<wsse:BinarySecurityToken '
+ 'xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-'
+ 'wssecurity-secext-1.0.xsd">'
+ l_token
+ '</wsse:BinarySecurityToken>'
+ '</wst:RequestedSecurityToken>'
+ '<wsp:AppliesTo '
+ 'xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">'
+ '<wsa:EndpointReference'
+ 'xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing">'
+ '<wsa:Address>uri:WindowsLiveID</wsa:Address>'
+ '</wsa:EndpointReference>'
+ '</wsp:AppliesTo>'
+ '</wst:RequestSecurityTokenResponse>';
result := new NameValueCollection(3);
result['wa'] := SecurityAlgorithm;
result['wresult'] := l_token;
if (ARetCode <> nil) then
begin
result['wctx'] := ARetCode;
end;
end;
/// <summary>
/// Returns the trusted login token in the format needed by the
/// trusted login gadget.
///
/// User to be trusted on the local site is passed in as string
/// 'user'.
/// </summary>
method WindowsLiveLogin.GetTrustedToken(AUser: String): String;
begin
result := nil;
if (AUser = nil) or (AUser.Length = 0) then
begin
debug('Error: GetTrustedToken: Invalid user specified.');
exit;
end;
var l_token := 'appid=' + AppId + '&uid='
+ HttpUtility.UrlEncode(AUser) + '&ts=' + getTimeStamp;
var l_sig := e64(SignToken(l_token));
if (l_sig = nil) then
begin
debug('Error: GetTrustedToken: Failed to sign the token.');
exit;
end;
l_token := l_token + '&sig=' + l_sig;
result := HttpUtility.UrlEncode(l_token);
end;
/// <summary>
/// Returns the trusted sign-in URL to use for the Windows Live
/// Login server.
/// </summary>
method WindowsLiveLogin.GetTrustedLoginUrl: String;
begin
result := SecureUrl + 'wlogin.srf';
end;
/// <summary>
/// Returns the trusted sign-out URL to use for the Windows Live
/// Login server.
/// </summary>
method WindowsLiveLogin.GetTrustedLogoutUrl: String;
begin
result := SecureUrl + 'logout.srf?appid=' + AppId;
end;
/// <summary>
/// Derives the signature or encryption key, given the secret key
/// and prefix as described in the SDK documentation.
/// </summary>
class method WindowsLiveLogin.derive(ASecret: String; APrefix: String): Array of Byte;
const cKeyLength = 16;
begin
using l_hashAlg := HashAlgorithm.Create('SHA256') do
begin
var l_data: Array of Byte := Encoding.Default.GetBytes(APrefix + ASecret);
var l_hashoutput: Array of Byte := l_hashAlg.ComputeHash(l_data);
var l_byteKey: Array of Byte := new Array of Byte(cKeyLength);
Array.Copy(l_hashoutput, l_byteKey, cKeyLength);
result := l_byteKey;
end;
end;
/// <summary>
/// Generates a timestamp suitable for the application
/// verifier token.
/// </summary>
class method WindowsLiveLogin.getTimeStamp: String;
begin
var l_refTime := new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var l_ts := DateTime.UtcNow - l_refTime;
result := UInt32(l_ts.TotalSeconds).ToString();
end;
/// <summary>
/// Base64-encode and URL-escape a byte array.
/// </summary>
class method WindowsLiveLogin.e64(Ab: array of Byte): String;
begin
result := nil;
if (Ab = nil) then
exit;
try
result := Convert.ToBase64String(Ab);
result := HttpUtility.UrlEncode(result);
except
on E: Exception do
begin
debug('Error: e64: Base64 conversion error: "' + E + '"');
end;
end;
end;
/// <summary>
/// URL-unescape and Base64-decode a string.
/// </summary>
class method WindowsLiveLogin.u64(AStr: String): Array of Byte;
begin
result := nil;
if (AStr = nil) then
exit;
AStr := HttpUtility.UrlDecode(AStr);
try
result := Convert.FromBase64String(AStr);
except
on E: Exception do
begin
debug('Error: u64: Base64 conversion error: "' + AStr + '", "' + E + '"');
end;
end;
end;
/// <summary>
/// Fetch the contents given a URL.
/// </summary>
class method WindowsLiveLogin.fetch(AUrl: String): String;
begin
result := nil;
try
var l_req := HttpWebRequest.Create(AUrl);
l_req.Method := 'GET';
var l_res := l_req.GetResponse;
using l_sr := new StreamReader(l_res.GetResponseStream, Encoding.UTF8) do
begin
result := l_sr.ReadToEnd;
end;
except
on E: Exception do
begin
debug('Error: fetch: Failed to get the document: "' + AUrl
+ '", "' + E + '"');
end;
end;
end;
method WindowsLiveLogin.User.setId(AId: String);
begin
if (AId = nil) then
begin
raise new ArgumentNullException('Error: User: Null id in token.');
end;
var l_re := new Regex('^\w+$');
if not l_re.IsMatch(AId) then
begin
raise new ArgumentException('Error: User: Invalid id: "' + AId + '"');
end;
m_id := AId;
end;
method WindowsLiveLogin.User.setTimestamp(ATimestamp: String);
begin
if (ATimestamp = nil) then
begin
raise new ArgumentNullException('Error: User: Null Timestamp in token.');
end;
var l_timestampInt: Integer;
try
l_timestampInt := Convert.ToInt32(ATimestamp);
except
raise new ArgumentException('Error: User: Invalid Timestamp: "'
+ ATimestamp + '"');
end;
var l_refTime := new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
m_timestamp := l_refTime.AddSeconds(l_timestampInt);
end;
method WindowsLiveLogin.User.setFlags(AFlags: String);
begin
UsePersistentCookie := false;
if (AFlags = nil) or (AFlags <> '') then
begin
try
UsePersistentCookie := ((Convert.ToInt32(AFlags) mod 2) = 1);
except
raise new ArgumentException('Error: User: Invalid flags: "' + AFlags + '"');
end;
end;
end;
constructor WindowsLiveLogin.User(ATimestamp: String; AId: String; AFlags: String;
AContext: String; AToken: String);
begin
setTimestamp(ATimestamp);
setId(AId);
setFlags(AFlags);
Context := AContext;
Token := AToken;
end;
end. |
unit txCache;
interface
type
TItemCacheNode=class(TObject)
end;
TItemCache=class(TObject)
private
FItems:array of record
id:integer;
n:TItemCacheNode;
end;
FSize,FCount:integer;
public
constructor Create;
destructor Destroy; override;
procedure Clear;
function Add(id:integer;n:TItemCacheNode):TItemCacheNode;
function Get(id:integer):TItemCacheNode;
property Item[id:integer]:TItemCacheNode read Get; default;
end;
TIndexCache=class(TObject)
private
FItems:array of record
id:integer;
value:integer;
end;
FSize,FCount:integer;
public
constructor Create;
destructor Destroy; override;
procedure Clear;
procedure Add(id,value:integer);
function Get(id:integer):integer;
property Item[id:integer]:integer read Get write Add; default;
end;
//ATTENTION: not thread-safe, don't use across threads
implementation
{ TItemCache }
constructor TItemCache.Create;
begin
inherited;
FSize:=0;
FCount:=0;
end;
destructor TItemCache.Destroy;
begin
Clear;
inherited;
end;
procedure TItemCache.Clear;
var
i:integer;
begin
for i:=FCount-1 downto 0 do FItems[i].n.Free;
FSize:=0;
SetLength(FItems,FSize);
FCount:=0;
end;
function TItemCache.Add(id:integer;n:TItemCacheNode):TItemCacheNode;
const
GrowStep=8;
var
a,b,c:integer;
begin
a:=0;
b:=FCount;
while (a<b) do //and thus not(FCount=0)
begin
c:=a+((b-a-1) div 2);
if FItems[c].id=id then b:=a else
if FItems[c].id<id then a:=c+1 else b:=c;
end;
if not(FCount=0) and (FItems[a].id=id) then
begin
FItems[a].n.Free;
FItems[a].n:=n;
end
else
begin
if (FCount=FSize) then
begin
inc(FSize,GrowStep);
SetLength(FItems,FSize);
end;
for c:=FCount-1 downto a do FItems[c+1]:=FItems[c];
FItems[a].id:=id;
FItems[a].n:=n;
inc(FCount);
end;
Result:=n;
end;
function TItemCache.Get(id:integer):TItemCacheNode;
var
a,b,c:integer;
begin
Result:=nil;//default
a:=0;
b:=FCount-1;
while (a<b) and (Result=nil) do
begin
c:=a+((b-a) div 2);
if FItems[a].id=id then Result:=FItems[a].n else
if FItems[b].id=id then Result:=FItems[b].n else
if FItems[c].id=id then Result:=FItems[c].n else
if FItems[c].id<id then a:=c+1 else b:=c-1;
end;
end;
{ TIndexCache }
constructor TIndexCache.Create;
begin
inherited;
FSize:=0;
FCount:=0;
end;
destructor TIndexCache.Destroy;
begin
Clear;
inherited;
end;
procedure TIndexCache.Clear;
begin
FSize:=0;
SetLength(FItems,FSize);
FCount:=0;
end;
procedure TIndexCache.Add(id, value: integer);
const
GrowStep=8;
var
a,b,c:integer;
begin
a:=0;
b:=FCount;
while (a<b) do //and thus not(FCount=0)
begin
c:=a+((b-a-1) div 2);
if FItems[c].id=id then b:=a else
if FItems[c].id<id then a:=c+1 else b:=c;
end;
if not(FCount=0) and (FItems[a].id=id) then
FItems[a].value:=value
else
begin
if (FCount=FSize) then
begin
inc(FSize,GrowStep);
SetLength(FItems,FSize);
end;
for c:=FCount-1 downto a do FItems[c+1]:=FItems[c];
FItems[a].id:=id;
FItems[a].value:=value;
inc(FCount);
end;
end;
function TIndexCache.Get(id: integer): integer;
var
a,b,c:integer;
begin
Result:=-1;//default
a:=0;
b:=FCount-1;
while (a<b) and (Result=-1) do
begin
c:=a+((b-a) div 2);
if FItems[a].id=id then Result:=FItems[a].value else
if FItems[b].id=id then Result:=FItems[b].value else
if FItems[c].id=id then Result:=FItems[c].value else
if FItems[c].id<id then a:=c+1 else b:=c-1;
end;
end;
end.
|
unit MainLib;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs,MainLoader;
type
TRunner = class(TService)
procedure ServiceStart(Sender: TService; var Started: Boolean);
private
{ Private declarations }
public
function GetServiceController: TServiceController; override;
{ Public declarations }
end;
var
Runner: TRunner;
implementation
{$R *.DFM}
function RunProcess(FileName: string; ShowCmd: DWORD; wait: Boolean; ProcID:PDWORD): Longword;
var
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
begin
FillChar(StartupInfo, SizeOf(StartupInfo), #0);
StartupInfo.cb := SizeOf(StartupInfo);
StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_FORCEONFEEDBACK;
StartupInfo.wShowWindow := ShowCmd;
if not CreateProcess(nil,@Filename[1],nil,nil,False,CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS,nil,nil,StartupInfo,ProcessInfo) then
Result := WAIT_FAILED
else
begin
if wait = FALSE then
begin
if ProcID <> nil then
ProcID^ := ProcessInfo.dwProcessId;
result := WAIT_FAILED;
exit;
end;
WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
GetExitCodeProcess(ProcessInfo.hProcess, Result);
end;
if ProcessInfo.hProcess <> 0 then
CloseHandle(ProcessInfo.hProcess);
if ProcessInfo.hThread <> 0 then
CloseHandle(ProcessInfo.hThread);
end;
procedure ServiceController(CtrlCode: DWord); stdcall;
begin
Runner.Controller(CtrlCode);
end;
function TRunner.GetServiceController: TServiceController;
begin
Result := ServiceController;
end;
procedure TRunner.ServiceStart(Sender: TService; var Started: Boolean);
begin
LoaderForm.Show;
end;
end.
|
unit MySqlite;
interface
uses
Windows, Classes, SysUtils, MyStringUtils;
type
HSQLCONTEXT = Pointer;
HSQLDB = Pointer;
HSQLSTMT = Pointer;
HSQLVALUE = Pointer;
{ TMySqlTable }
TMySqlTable = class(TObject)
private
FColumns: TStringList;
FQuery: HSQLSTMT;
protected
function GetFieldIndex(const AName: WideString): Integer;
procedure UpdateColumns;
public
constructor Create(AQuery: HSQLSTMT); virtual;
destructor Destroy; override;
function NextRecord: Boolean;
// Read
function ReadString(AIndex: Integer): WideString; overload;
function ReadString(const AName: WideString): WideString; overload;
function ReadInteger(AIndex: Integer): Integer; overload;
function ReadInteger(const AName: WideString): Integer; overload;
end;
{ TMySqlBase }
TMySqlBase = class(TObject)
private
FDataBase: HSQLDB;
FLastQuery: WideString;
FShowErrors: Boolean;
protected
function CheckError(AError: Integer): Boolean;
procedure ErrorMessage(AMsg: PWideChar);
function PrepareQuery(const AQuery: WideString; var AStmt: HSQLSTMT): Boolean;
public
constructor Create(const AFile: WideString); virtual;
destructor Destroy; override;
function ExecQuery(const AQuery: WideString): Boolean; overload;
function ExecQuery(const AQuery: WideString; out ATable: TMySqlTable): Boolean; overload;
property ShowErrors: Boolean read FShowErrors write FShowErrors;
end;
implementation
const
sqlite_dll = 'sqlite3.dll';
const
// Values
SQLITE_INTEGER = 1;
SQLITE_FLOAT = 2;
SQLITE_TEXT = 3;
SQLITE_BLOB = 4;
SQLITE_NULL = 5;
SQLITE_OK = 0;
SQLITE_ROW = 100;
SQLITE_UTF16 = 4;
SQLErrorMessage = 'SQLite Error: ' + CRLF + '%s' + CRLF + 'Last query:' + CRLF + '%s';
type
TSQLCompare = function (AUserData: Pointer; P1Size: Integer; P1: PWideChar; P2Size: Integer; P2: PWideChar): Integer; cdecl;
TSQLFunction = procedure (AContext: HSQLCONTEXT; ACount: Integer; AVars: PPointerArray); cdecl;
TSQLFunctionFinal = procedure (AContext: HSQLCONTEXT); cdecl;
TSQLDestroyText = procedure (P: PWideChar); cdecl;
// Misc
function sqlite3_close(ADataBase: HSQLDB): Integer; cdecl; external sqlite_dll;
function sqlite3_finalize(AStmt: HSQLSTMT): Integer; cdecl; external sqlite_dll;
function sqlite3_open16(AFile: PWideChar; var ADataBase: HSQLDB): Integer; cdecl; external sqlite_dll;
function sqlite3_prepare16_v2(ADataBase: HSQLDB; AQuery: PWideChar; ALen: Integer;
var AStmt: HSQLSTMT; var ATail: PWideChar): Integer; cdecl; external sqlite_dll;
function sqlite3_step(AStmt: HSQLSTMT): Integer; cdecl; external sqlite_dll;
function sqlite3_errmsg16(ADataBase: HSQLDB): PWideChar; cdecl; external sqlite_dll;
function sqlite3_column_count(AStatement: HSQLSTMT): Integer; cdecl; external sqlite_dll;
function sqlite3_create_collation16(ADataBase: HSQLDB; AName: PWideChar; ATextType: Integer; AUserData: Pointer; ACompareProc: TSQLCompare): Integer; cdecl; external sqlite_dll;
function sqlite3_busy_timeout(ADataBase: HSQLDB; AMs: Integer): Integer; cdecl; external sqlite_dll;
function sqlite3_create_function16(ADataBase: HSQLDB; const AName: PWideChar; AArg, AEnc: Integer;
AUserData: Pointer; AFunc, AStep: TSQLFunction; AFinal: TSQLFunctionFinal): Integer; cdecl; external sqlite_dll;
// Read
function sqlite3_column_int(AStatement: HSQLSTMT; AColumn: Integer): Integer; cdecl; external sqlite_dll;
function sqlite3_column_name16(AStatement: HSQLSTMT; ID: Integer): PWideChar; cdecl; external sqlite_dll;
function sqlite3_column_text16(AStatement: HSQLSTMT; AColumn: Integer): PWideChar; cdecl; external sqlite_dll;
function sqlite3_column_bytes16(AStatement: HSQLSTMT; AColumn: Integer): Integer; cdecl; external sqlite_dll;
// Values
function sqlite3_value_bytes16(AValue: HSQLVALUE): Integer; cdecl; external sqlite_dll;
function sqlite3_value_text16(AValue: HSQLVALUE): PWideChar; cdecl; external sqlite_dll;
function sqlite3_value_type(AValue: HSQLVALUE): Integer; cdecl; external sqlite_dll;
// Result
procedure sqlite3_result_text16(AContext: HSQLCONTEXT; P: PWideChar; ASize: Integer; ADestroyCallback: TSQLDestroyText); cdecl; external sqlite_dll;
procedure sqlite3_result_value(AContext: HSQLCONTEXT; AValue: HSQLVALUE); cdecl; external sqlite_dll;
// Strings
function SQLite_VarToText(AValue: Pointer): WideString;
begin
SetString(Result, sqlite3_value_text16(AValue), sqlite3_value_bytes16(AValue) div SizeOf(WideChar));
end;
// Functions
procedure SQLite_FreeText(P: PWideChar); cdecl;
begin
FreeMem(P);
end;
function UnicodeCompare(AUserData: Pointer; P1Size: Integer; P1: PWideChar; P2Size: Integer; P2: PWideChar): Integer; cdecl;
begin
Result := CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE,
P1, P1Size div SizeOf(WideChar), P2, P2Size div SizeOf(WideChar)) - CSTR_EQUAL;
end;
procedure UnicodeUpper(AContext: HSQLCONTEXT; ACount: Integer; AVars: PPointerArray); cdecl;
var
ABuffer: WideString;
begin
if sqlite3_value_type(AVars^[0]) = SQLITE_TEXT then
begin
ABuffer := WideUpperCase(SQLite_VarToText(AVars^[0]));
sqlite3_result_text16(AContext, WideAllocStr(ABuffer), Length(ABuffer) * SizeOf(WideChar), @SQLite_FreeText);
end
else
sqlite3_result_value(AContext, AVars^[0]);
end;
{ TMySqlTable }
constructor TMySqlTable.Create(AQuery: HSQLSTMT);
begin
inherited Create;
FQuery := AQuery;
FColumns := TStringList.Create;
end;
destructor TMySqlTable.Destroy;
begin
sqlite3_finalize(FQuery);
FreeAndNil(FColumns);
inherited Destroy;
end;
function TMySqlTable.GetFieldIndex(const AName: WideString): Integer;
begin
if FColumns.Count = 0 then
UpdateColumns;
Result := FColumns.IndexOf(AName);
end;
function TMySqlTable.NextRecord: Boolean;
begin
Result := (sqlite3_step(FQuery) = SQLITE_ROW);
end;
function TMySqlTable.ReadInteger(AIndex: Integer): Integer;
begin
Result := sqlite3_column_int(FQuery, AIndex);
end;
function TMySqlTable.ReadInteger(const AName: WideString): Integer;
begin
Result := ReadInteger(GetFieldIndex(AName));
end;
function TMySqlTable.ReadString(AIndex: Integer): WideString;
var
ASize: Integer;
S: PWideChar;
begin
ASize := sqlite3_column_bytes16(FQuery, AIndex);
S := sqlite3_column_text16(FQuery, AIndex);
SetString(Result, S, ASize div SizeOf(WideChar));
end;
function TMySqlTable.ReadString(const AName: WideString): WideString;
begin
Result := ReadString(GetFieldIndex(AName));
end;
procedure TMySqlTable.UpdateColumns;
var
ACount, I: Integer;
begin
FColumns.Clear;
ACount := sqlite3_column_count(FQuery);
FColumns.Capacity := ACount;
for I := 0 to ACount - 1 do
FColumns.Add(sqlite3_column_name16(FQuery, I));
end;
{ TMySqlBase }
constructor TMySqlBase.Create(const AFile: WideString);
begin
inherited Create;
if FDataBase = nil then
begin
FShowErrors := True;
CheckError(sqlite3_open16(PWideChar(AFile), FDataBase));
CheckError(sqlite3_create_collation16(FDataBase, 'UNICODE', SQLITE_UTF16, nil, @UnicodeCompare));
CheckError(sqlite3_create_function16(FDataBase, 'UPPER', 1, SQLITE_UTF16, nil, @UnicodeUpper, nil, nil));
sqlite3_busy_timeout(FDataBase, 100);
end;
end;
destructor TMySqlBase.Destroy;
begin
sqlite3_close(FDataBase);
inherited Destroy;
end;
function TMySqlBase.CheckError(AError: Integer): Boolean;
begin
Result := (AError = SQLITE_OK);
if not Result then
ErrorMessage(sqlite3_errmsg16(FDataBase));
end;
procedure TMySqlBase.ErrorMessage(AMsg: PWideChar);
var
S: WideString;
begin
if ShowErrors then
begin
S := Format(SQLErrorMessage, [AMsg, FLastQuery]);
MessageBoxW(HWND_DESKTOP, PWideChar(S), nil, MB_ICONERROR or MB_OK);
end;
end;
function TMySqlBase.ExecQuery(const AQuery: WideString): Boolean;
var
AStatement: HSQLSTMT;
begin
Result := PrepareQuery(AQuery, AStatement);
if Result then
try
sqlite3_step(AStatement);
finally
sqlite3_finalize(AStatement);
end;
end;
function TMySqlBase.ExecQuery(const AQuery: WideString; out ATable: TMySqlTable): Boolean;
var
AStatement: HSQLSTMT;
begin
Result := PrepareQuery(AQuery, AStatement);
if Result then
begin
Result := (sqlite3_step(AStatement) = SQLITE_ROW);
if Result then
ATable := TMySqlTable.Create(AStatement)
else
sqlite3_finalize(AStatement);
end;
end;
function TMySqlBase.PrepareQuery(const AQuery: WideString; var AStmt: HSQLSTMT): Boolean;
var
ATail: PWideChar;
begin
AStmt := nil;
FLastQuery := AQuery;
Result := CheckError(sqlite3_prepare16_v2(FDataBase, PWideChar(AQuery),
Length(AQuery) * SizeOf(WideChar), AStmt, ATail));
end;
end.
|
unit trl_upersistxml;
interface
uses
trl_irttibroker, trl_ipersist, trl_ifactory,
trl_urttibroker,
DOM, XMLRead, XMLWrite, xpath,
SysUtils, fgl, classes, base64;
const
cSID = 'SID';
cRefID = 'refid';
cRefClass = 'refclass';
cValue = 'Value';
cRoot = 'root';
cStoreSettings = 'storesettings';
cLastSid = 'lastsid';
cMemo = 'memo';
type
{ TXmlStore }
TXmlStore = class(TInterfacedObject, IPersistStoreDevice)
private type
{ TSIDManager }
TSIDManager = class
private
fLast: integer;
function GetStoreSettingsElement(ADoc: TXMLDocument): TDOMElement;
public
procedure Load(ADoc: TXMLDocument);
procedure Save(ADoc: TXMLDocument);
function New: TSID;
end;
private
const
cListItemTag = 'i';
cListItemNilTag = 'n';
private
fFactory: IPersistFactory;
fFile: string;
fDoc: TXMLDocument;
fSIDMgr: TSIDManager;
function GetDoc: TXMLDocument;
function GetDataClassEl(const ADataClassName: string; ACanCreate: Boolean): TDOMElement;
class function FindElement(const AContextEl: TDOMElement; const AXPath: string): TDOMElement;
function FindStoreElForSID(const ADataClassEl: TDOMElement; const ASID: TSID): TDOMElement; overload;
function FindStoreElForSID(const ASID: TSID): TDOMElement; overload;
function GetDataStoreElForSID(const ADataClassEl: TDOMElement; const ASID: TSID): TDOMElement; overload;
function GetDataStoreElForSID(const ASID: TSID): TDOMElement; overload;
function FindStoreElForName(const ADataClassEl: TDOMElement; const AName: string): TDOMElement; overload;
function FindStoreElForName(const AName: string): TDOMElement; overload;
function GetDataStoreElForName(const ADataClassEl: TDOMElement; const AName: string): TDOMElement; overload;
function GetDataStoreElForName(const AName: string): TDOMElement; overload;
//save
procedure SaveDataItemValue(AStoreEl: TDOMElement; const AName, AValue: string);
procedure SaveDataItemMemo(AStoreEl: TDOMElement; const AName, AValue: string);
procedure SaveDataItemStream(AStoreEl: TDOMElement; AValue: TStream);
procedure SaveDataItemObject(AStoreEl: TDOMElement; const AValue: TObject; AIsReference: Boolean);
procedure SaveDataItemRef(AStoreEl: TDOMElement; const AName: string;
const AValue: IPersistRef);
procedure SaveDataList(AStoreEl: TDOMElement; ADataItem: IRBDataItem);
procedure SaveData(AStoreEl: TDOMElement; AData: IRBData);
//load
function LoadDataItemValue(AStoreEl: TDOMElement; const AName: string): string;
function LoadDataItemMemo(AStoreEl: TDOMElement; const AName: string): string;
procedure LoadDataItemStream(AStoreEl: TDOMElement; const AName: string; AValue: TStream);
procedure LoadDataItemObject(AStoreEl: TDOMElement; const AData: IRBData);
procedure LoadDataItemRef(AStoreEl: TDOMElement; const AValue: IPersistRef);
procedure LoadDataList(AStoreEl: TDOMElement; ADataItem: IRBDataItem);
procedure LoadData(AStoreEl: TDOMElement; AData: IRBData);
protected
procedure CheckOpen;
property Doc: TXMLDocument read GetDoc;
public
constructor Create(AFactory: IFactory; const AFile: string);
constructor Create;
destructor Destroy; override;
procedure AfterConstruction; override;
// IPersistStoreDevice
procedure Load(const ASID: TSID; AData: IRBData);
procedure Save(const ASID: TSID; AData: IRBData);
procedure Delete(const ASID: TSID);
function NewSID: TSID;
function GetSIDClass(const ASID: TSID): string;
procedure Open; overload;
procedure Open(const AFile: string); overload;
procedure Open(const AStream: TStream); overload;
procedure AfterOpen;
procedure Close; overload;
procedure Close(const AStream: TStream); overload;
procedure Flush;
function GetSIDs(const AClass: string): ISIDList;
published
property Factory: IPersistFactory read fFactory write fFactory;
property XMLFile: string read fFile write fFile;
end;
implementation
type
{ EXMLStore }
EXMLStore = class(Exception)
public
class procedure ClassNotExists(const AClass: string);
class procedure ClassForSIDNotExists(const ASID: string);
class procedure ClassForNameNotExists(const AName: string);
class procedure ObjectNotExists(const AClass, AName: string); overload;
class procedure ObjectNotExists(const AClass: string; AID: integer); overload;
class procedure MoreObjectWithNameExists(const AClass, AName: string); overload;
class procedure MoreObjectWithNameExists(const AClass: string; AID: integer); overload;
class procedure CannotAddItemWithoutSIDToList(const AClass: string);
class procedure CannotFindReferencedSID(const AOwner: string; ASID: string);
end;
{ TXmlStore.TSIDManager }
function TXmlStore.TSIDManager.GetStoreSettingsElement(ADoc: TXMLDocument): TDOMElement;
begin
Result := FindElement(ADoc.DocumentElement, './' + cStoreSettings);
if Result = nil then
begin
Result := ADoc.CreateElement(cStoreSettings);
ADoc.DocumentElement.AppendChild(Result);
end;
end;
procedure TXmlStore.TSIDManager.Load(ADoc: TXMLDocument);
var
mEl: TDOMElement;
begin
mEl := GetStoreSettingsElement(ADoc);
fLast := StrToIntDef(mEl.AttribStrings[cLastSid], 1);
end;
procedure TXmlStore.TSIDManager.Save(ADoc: TXMLDocument);
var
mEl: TDOMElement;
begin
mEl := GetStoreSettingsElement(ADoc);
mEl.AttribStrings[cLastSid] := IntToStr(fLast);
end;
function TXmlStore.TSIDManager.New: TSID;
begin
inc(fLast);
Result := fLast;
end;
{ EXMLStore }
class procedure EXMLStore.ClassNotExists(const AClass: string);
begin
raise EXMLStore.CreateFmt('Class %s not found in store', [AClass]);
end;
class procedure EXMLStore.ClassForSIDNotExists(const ASID: string);
begin
raise EXMLStore.CreateFmt('Cannot find class for SID %s', [ASID]);
end;
class procedure EXMLStore.ClassForNameNotExists(const AName: string);
begin
raise EXMLStore.CreateFmt('Cannot find class for Name %s', [AName]);
end;
class procedure EXMLStore.ObjectNotExists(const AClass, AName: string);
begin
raise EXMLStore.CreateFmt('Object %s.%s not found in store', [AClass, AName]);
end;
class procedure EXMLStore.ObjectNotExists(const AClass: string; AID: integer);
begin
raise EXMLStore.CreateFmt('Object %s.%d not found in store', [AClass, AID]);
end;
class procedure EXMLStore.MoreObjectWithNameExists(const AClass, AName: string);
begin
raise EXMLStore.CreateFmt('Object %s.%s exists more then once in store', [AClass, AName]);
end;
class procedure EXMLStore.MoreObjectWithNameExists(const AClass: string;
AID: integer);
begin
raise EXMLStore.CreateFmt('Object %s.%d exists more then once in store', [AClass, AID]);
end;
class procedure EXMLStore.CannotAddItemWithoutSIDToList(const AClass: string);
begin
raise EXMLStore.CreateFmt('Object of class %s do not have SID stored - cannot add to list', [AClass]);
end;
class procedure EXMLStore.CannotFindReferencedSID(const AOwner: string;
ASID: string);
begin
raise EXMLStore.CreateFmt('Object %s refer to not exists SID %s', [AOwner, ASID]);
end;
{ TXmlStore }
function TXmlStore.GetDoc: TXMLDocument;
begin
if fDoc= nil then
raise exception.Create('not opend');
Result := fDoc;
end;
procedure TXmlStore.SaveData(AStoreEl: TDOMElement; AData: IRBData);
var
i: integer;
mObjStoreEl: TDOMElement;
begin
for i := 0 to AData.Count - 1 do
begin
if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IPersistMany) then
SaveDataList(AStoreEl, AData[i])
else if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IPersistRef) then
SaveDataItemRef(AStoreEl, AData[i].Name, AData[i].AsInterface as IPersistRef)
else if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IRBData) then
begin
mObjStoreEl := Doc.CreateElement(AData[i].Name);
AStoreEl.AppendChild(mObjStoreEl);
SaveData(mObjStoreEl, AData[i].AsInterface as IRBData)
end
else if AData[i].IsObject then
begin
if AData[i].AsObject <> nil then
begin
mObjStoreEl := Doc.CreateElement(AData[i].Name);
AStoreEl.AppendChild(mObjStoreEl);
SaveDataItemObject(mObjStoreEl, AData[i].AsObject, {AData[i].IsReference} False);
end;
end
else if AData[i].IsMemo then
begin
SaveDataItemMemo(AStoreEl, AData[i].Name, AData[i].AsPersist);
end
else if AData[i].IsInterface then
begin
//maybe in future some special interface
end
else
begin
SaveDataItemValue(AStoreEl, AData[i].Name, AData[i].AsPersist);
end;
end;
end;
procedure TXmlStore.LoadData(AStoreEl: TDOMElement; AData: IRBData);
var
i: integer;
mObjStoreEl: TDOMElement;
mData: IRBData;
mID: string;
begin
for i := 0 to AData.Count - 1 do
begin
if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IPersistMany) then
LoadDataList(AStoreEl, AData[i])
else
if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IPersistRef) then
begin
mObjStoreEl := AStoreEl.FindNode(AData[i].Name) as TDOMElement;
if mObjStoreEl <> nil then
LoadDataItemRef(mObjStoreEl, AData[i].AsInterface as IPersistRef)
end
else if (AData[i].IsInterface) and Supports(AData[i].AsInterface, IRBData) then
begin
mObjStoreEl := AStoreEl.FindNode(AData[i].Name) as TDOMElement;
if mObjStoreEl <> nil then
LoadData(mObjStoreEl, AData[i].AsInterface as IRBData)
end
else
if AData[i].IsObject then
begin
if AData[i].AsObject is TStream then begin
LoadDataItemStream(AStoreEl, AData[i].Name, AData[i].AsObject as TStream);
end
else
begin
mObjStoreEl := AStoreEl.FindNode(AData[i].Name) as TDOMElement;
if mObjStoreEl = nil then
Continue;
mData := fFactory.CreateObject(AData[i].ClassName);
mData.UnderObject := AData[i].AsObject;
LoadDataItemObject(mObjStoreEl, mData);
end;
end
else
if AData[i].IsMemo then
begin
AData[i].AsPersist := LoadDataItemMemo(AStoreEl, AData[i].Name);
end
else
if AData[i].IsID then
begin
mID := LoadDataItemValue(AStoreEl, AData[i].Name);
// just because of possible older item stored without ID will not overwrite
// id created for new object with empty value
if mID <> '' then
AData[i].AsPersist := mID;
end
else
if AData[i].IsInterface then
begin
//maybe in future some special interface
end
else
begin
AData[i].AsPersist := LoadDataItemValue(AStoreEl, AData[i].Name);
end;
end;
end;
procedure TXmlStore.CheckOpen;
begin
if fDoc <> nil then
raise Exception.Create('already opened');
end;
function TXmlStore.LoadDataItemValue(AStoreEl: TDOMElement; const AName: string): string;
begin
Result := AStoreEl.AttribStrings[AName];
end;
function TXmlStore.LoadDataItemMemo(AStoreEl: TDOMElement; const AName: string
): string;
var
mStoreEl: TDOMElement;
mMemoNode: TDOMCDATASection;
begin
Result := '';
mStoreEl := FindElement(AStoreEl, './' + AName);
if mStoreEl = nil then
Exit;
mMemoNode := mStoreEl.ChildNodes[0] as TDOMCDATASection;
Result := mMemoNode.TextContent;
end;
procedure TXmlStore.LoadDataItemStream(AStoreEl: TDOMElement;
const AName: string; AValue: TStream);
var
mStoreEl: TDOMElement;
mMemoNode: TDOMCDATASection;
mInstream: TBytesStream;
mDecoder: TBase64DecodingStream;
begin
mStoreEl := FindElement(AStoreEl, './' + AName);
if mStoreEl = nil then begin
AValue.Size := 0;
Exit;
end;
mMemoNode := mStoreEl.ChildNodes[0] as TDOMCDATASection;
mInstream := TBytesStream.Create(TEncoding.ASCII.GetBytes(mMemoNode.TextContent));
try
mDecoder := TBase64DecodingStream.Create(mInstream);
try
AValue.CopyFrom(mDecoder, mDecoder.Size);
finally
mDecoder.Free;
end;
finally
mInstream.Free;
end;
end;
procedure TXmlStore.LoadDataItemObject(AStoreEl: TDOMElement; const AData: IRBData);
begin
LoadData(AStoreEl, AData);
end;
procedure TXmlStore.LoadDataItemRef(AStoreEl: TDOMElement; const AValue: IPersistRef);
var
mSID: TSID;
mRefStoreEl: TDOMElement;
mData: IRBData;
begin
if AStoreEl.AttribStrings[cRefID] <> '' then
begin
mSID := AStoreEl.AttribStrings[cRefID];
AValue.SID := mSID;
end;
end;
procedure TXmlStore.LoadDataList(AStoreEl: TDOMElement; ADataItem: IRBDataItem);
var
mStoreEl: TDOMElement;
mStoreItemEl: TDOMElement;
i: integer;
mMany: IPersistMany;
begin
if ADataItem.IsObject then
mMany := ADataItem.AsObject as IPersistMany
else if ADataItem.IsInterface then
mMany := ADataItem.AsInterface as IPersistMany
else
raise Exception.Create('not list');
mStoreEl := AStoreEl.FindNode(ADataItem.Name) as TDOMElement;
if mStoreEl = nil then
Exit;
mMany.Count := mStoreEl.ChildNodes.Count;
for i := 0 to mStoreEl.ChildNodes.Count - 1 do
begin
mStoreItemEl := mStoreEl.ChildNodes[i] as TDOMElement;
if mMany.IsObject then
begin
// only when ID is stored, otherwise is nil
if mStoreItemEl.NodeName = cListItemNilTag then
mMany.AsObject[i] := nil
else
LoadDataItemObject(mStoreItemEl, mMany.AsPersistData[i]);
end
else
if Supports(mMany, IPersistManyRefs) then
LoadDataItemRef(mStoreItemEl, mMany.AsInterface[i] as IPersistRef)
else
mMany.AsPersist[i] := LoadDataItemValue(mStoreItemEl, cValue);
end;
end;
function TXmlStore.GetDataClassEl(const ADataClassName: string;
ACanCreate: Boolean): TDOMElement;
begin
Result := Doc.DocumentElement.FindNode(ADataClassName) as TDOMElement;
if Result = nil then
begin
if ACanCreate then
begin
Result := Doc.CreateElement(ADataClassName);
Doc.DocumentElement.AppendChild(Result);
end
//else
// EXMLStore.ClassNotExists(ADataClassName);
end;
end;
class function TXmlStore.FindElement(const AContextEl: TDOMElement;
const AXPath: string): TDOMElement;
var
mXPV: TXPathVariable;
begin
mXPV := EvaluateXPathExpression(AXPath, AContextEl);
case mXPV.AsNodeSet.Count of
0: Result := nil;
1: Result := TDOMElement(mXPV.AsNodeSet[0]);
else
EXMLStore.MoreObjectWithNameExists(AContextEl.NodeName, AXPath);
end;
end;
function TXmlStore.GetDataStoreElForSID(const ADataClassEl: TDOMElement;
const ASID: TSID): TDOMElement;
begin
Result := FindStoreElForSID(ADataClassEl, ASID);
if Result = nil then
EXMLStore.ClassForSIDNotExists(ASID);
end;
function TXmlStore.FindStoreElForSID(const ASID: TSID): TDOMElement;
begin
Result := FindElement(Doc.DocumentElement, '//*[@SID=''' + ASID + ''']');
end;
function TXmlStore.FindStoreElForSID(const ADataClassEl: TDOMElement;
const ASID: TSID): TDOMElement;
begin
Result := FindElement(ADataClassEl, './*[@SID=''' + ASID + ''']');
end;
function TXmlStore.GetDataStoreElForSID(const ASID: TSID): TDOMElement;
begin
Result := FindStoreElForSID(ASID);
if Result = nil then
EXMLStore.ClassForSIDNotExists(ASID);
end;
function TXmlStore.FindStoreElForName(const ADataClassEl: TDOMElement;
const AName: string): TDOMElement;
begin
Result := FindElement(ADataClassEl, './*[@Name=''' + AName + ''']');
end;
function TXmlStore.FindStoreElForName(const AName: string): TDOMElement;
begin
Result := FindElement(Doc.DocumentElement, '//*[@Name=''' + AName + ''']');
end;
function TXmlStore.GetDataStoreElForName(const ADataClassEl: TDOMElement;
const AName: string): TDOMElement;
begin
Result := FindStoreElForName(ADataClassEl, AName);
if Result = nil then
EXMLStore.ClassForNameNotExists(AName);
end;
function TXmlStore.GetDataStoreElForName(const AName: string): TDOMElement;
begin
Result := FindStoreElForName(AName);
if Result = nil then
EXMLStore.ClassForNameNotExists(AName);
end;
procedure TXmlStore.SaveDataItemValue(AStoreEl: TDOMElement; const AName,
AValue: string);
begin
if AValue <> '' then
AStoreEl.AttribStrings[AName] := AValue;
end;
procedure TXmlStore.SaveDataItemMemo(AStoreEl: TDOMElement; const AName,
AValue: string);
var
mStoreEl: TDOMElement;
mMemoNode: TDOMCDATASection;
begin
if AValue <> '' then
begin
mStoreEl := Doc.CreateElement(AName);
AStoreEl.AppendChild(mStoreEl);
mMemoNode := Doc.CreateCDATASection(AValue);
mStoreEl.AppendChild(mMemoNode);
end;
end;
procedure TXmlStore.SaveDataItemStream(AStoreEl: TDOMElement; AValue: TStream);
var
mMemoNode: TDOMCDATASection;
mValue: DOMString;
mEncoder: TBase64EncodingStream;
mEncoded: TBytesStream;
begin
if AValue <> nil then
begin
mEncoded := TBytesStream.Create;
try
mEncoder := TBase64EncodingStream.Create(mEncoded);
try
AValue.Position := 0;
mEncoder.CopyFrom(AValue, AValue.Size);
finally
mEncoder.Free;
end;
mValue := TEncoding.ASCII.GetString(mEncoded.Bytes, 0, mEncoded.Size);
mMemoNode := Doc.CreateCDATASection(mValue);
AStoreEl.AppendChild(mMemoNode);
finally
mEncoded.Free;
end;
end;
end;
procedure TXmlStore.SaveDataItemObject(AStoreEl: TDOMElement;
const AValue: TObject; AIsReference: Boolean);
var
mSID: TSID;
mData: IRBData;
begin
if AValue is TStream then
SaveDataItemStream(AStoreEl, AValue as TStream)
else
if AValue <> nil then begin
mData := fFactory.CreateObject(AValue.ClassName);
mData.UnderObject := AValue;
SaveData(AStoreEl, mData);
end;
end;
procedure TXmlStore.SaveDataItemRef(AStoreEl: TDOMElement; const AName: string;
const AValue: IPersistRef);
var
mObjStoreEl: TDOMElement;
begin
if (AValue <> nil) and (AValue.Data <> nil) then
begin
//if AValue.SID.IsClear then
// fStore.Save
mObjStoreEl := Doc.CreateElement(AName);
AStoreEl.AppendChild(mObjStoreEl);
SaveDataItemValue(mObjStoreEl, cRefClass, AValue.Data.ClassName);
SaveDataItemValue(mObjStoreEl, cRefID, AValue.SID);
end;
end;
procedure TXmlStore.SaveDataList(AStoreEl: TDOMElement; ADataItem: IRBDataItem);
var
mStoreEl: TDOMElement;
mStoreItemEl: TDOMElement;
i: integer;
mMany: IPersistMany;
begin
if ADataItem.IsObject then
mMany := ADataItem.AsObject as IPersistMany
else if ADataItem.IsInterface then
mMany := ADataItem.AsInterface as IPersistMany
else
raise Exception.Create('not list');
if mMany.Count = 0 then
Exit;
mStoreEl := Doc.CreateElement(ADataItem.Name);
AStoreEl.AppendChild(mStoreEl);
for i := 0 to mMany.Count - 1 do
begin
// create element for store list item
if mMany.IsObject and (mMany.AsObject[i] = nil) then
begin
mStoreItemEl := Doc.CreateElement(cListItemNilTag);
mStoreEl.AppendChild(mStoreItemEl);
end
else
if Supports(mMany, IPersistManyRefs) then
SaveDataItemRef(mStoreEl, cListItemTag, mMany.AsInterface[i] as IPersistRef)
else
begin
mStoreItemEl := Doc.CreateElement(cListItemTag);
mStoreEl.AppendChild(mStoreItemEl);
// store data
if mMany.IsObject then
SaveDataItemObject(mStoreItemEl, mMany.AsObject[i], False)
else
SaveDataItemValue(mStoreItemEl, cValue, mMany.AsPersist[i]);
end;
end;
end;
procedure TXmlStore.Load(const ASID: TSID; AData: IRBData);
var
mStoreEl: TDOMElement;
begin
mStoreEl := FindElement(Doc.DocumentElement, './' + AData.ClassName + '/' + cListItemTag + '[@' + cSID + '=''' + ASID + ''']');
if mStoreEl <> nil then begin
LoadData(mStoreEl, AData);
end;
end;
procedure TXmlStore.Save(const ASID: TSID; AData: IRBData);
var
mClassEl: TDOMElement;
mStoreEl: TDOMElement;
mOriginalEl: TDOMElement;
begin
mClassEl := GetDataClassEl(AData.ClassName, True);
mStoreEl := Doc.CreateElement(cListItemTag);
mOriginalEl := FindStoreElForSID(mClassEl, ASID);
if mOriginalEl <> nil then
begin
mClassEl.InsertBefore(mStoreEl, mOriginalEl);
mOriginalEl.ParentNode.DetachChild(mOriginalEl);
mOriginalEl.Free;
end
else
begin
mClassEl.AppendChild(mStoreEl);
end;
mStoreEl.AttribStrings[cSID] := ASID;
//
SaveData(mStoreEl, AData);
end;
procedure TXmlStore.Delete(const ASID: TSID);
var
mStoreEl: TDOMElement;
mXPV: TXPathVariable;
i: integer;
mNode: TDOMNode;
begin
mXPV := EvaluateXPathExpression('//*[@' + cRefID + '=''' + ASID + ''']', Doc.DocumentElement);
try
for i := 0 to mXPV.AsNodeSet.Count - 1 do
begin
mNode := TDOMNode(mXPV.AsNodeSet[i]);
mNode.ParentNode.RemoveChild(mNode);
mNode.Free;
end;
finally
mXPV.Free;
end;
mStoreEl := FindStoreElForSID(ASID);
if mStoreEl <> nil then
begin
mStoreEl.ParentNode.DetachChild(mStoreEl);
mStoreEl.Free;
end;
end;
function TXmlStore.NewSID: TSID;
begin
Result := fSIDMgr.New;
end;
function TXmlStore.GetSIDClass(const ASID: TSID): string;
var
mStoreEl: TDOMElement;
begin
Result := '';
mStoreEl := FindStoreElForSID(ASID);
if mStoreEl <> nil then
Result := mStoreEl.ParentNode.NodeName;
end;
procedure TXmlStore.Open;
begin
CheckOpen;
if (fFile <> '') and FileExists(fFile) then
ReadXMLFile(fDoc, fFile);
if fDoc = nil then
begin
fDoc := TXMLDocument.Create;
fDoc.AppendChild(fDoc.CreateElement(cRoot));
end;
AfterOpen;
end;
procedure TXmlStore.Open(const AFile: string);
begin
CheckOpen;
fFile := AFile;
Open;
end;
procedure TXmlStore.Open(const AStream: TStream);
begin
CheckOpen;
ReadXMLFile(fDoc, AStream);
AfterOpen;
end;
procedure TXmlStore.AfterOpen;
begin
fSIDMgr.Load(fDoc);
end;
procedure TXmlStore.Close;
begin
Flush;
FreeAndNil(fDoc);
end;
procedure TXmlStore.Close(const AStream: TStream);
begin
fSIDMgr.Save(Doc);
WriteXMLFile(fDoc, AStream);
FreeAndNil(fDoc);
end;
procedure TXmlStore.Flush;
begin
if (fFile <> '') and (fDoc <> nil) then begin
fSIDMgr.Save(Doc);
WriteXMLFile(Doc, fFile);
end;
end;
function TXmlStore.GetSIDs(const AClass: string): ISIDList;
var
mClassEl: TDOMElement;
i: integer;
begin
Result := Factory.Create(ISIDList) as ISIDList;
mClassEl := GetDataClassEl(AClass, False);
if mClassEl = nil then
Exit;
Result.Count := mClassEl.ChildNodes.Count;
for i := 0 to mClassEl.ChildNodes.Count - 1 do
begin
Result[i] := (mClassEl.ChildNodes[i] as TDOMElement).AttribStrings[cSID];
end;
end;
constructor TXmlStore.Create(AFactory: IFactory; const AFile: string);
begin
// fFactory := AFactory;
fFile := AFile;
Create;
end;
constructor TXmlStore.Create;
begin
// GetDoc;
end;
destructor TXmlStore.Destroy;
begin
Flush;
FreeAndNil(fSIDMgr);
inherited Destroy;
end;
procedure TXmlStore.AfterConstruction;
begin
inherited AfterConstruction;
fSIDMgr := TSIDManager.Create;
end;
end.
|
unit LIB.Complex;
interface //#################################################################### ■
uses LIB;
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleC
TDoubleC = record
private
///// アクセス
function GetAbs2 :Double;
function GetAbso :Double;
public
R :Double;
I :Double;
/////
constructor Create( const R_,I_:Double );
///// プロパティ
property Abs2 :Double read GetAbs2;
property Abso :Double read GetAbso;
///// 演算子
class operator Negative( const V_:TDoubleC ) :TDoubleC;
class operator Positive( const V_:TDoubleC ) :TDoubleC;
class operator Add( const A_,B_:TDoubleC ) :TDoubleC;
class operator Subtract( const A_,B_:TDoubleC ) :TDoubleC;
class operator Multiply( const A_,B_:TDoubleC ) :TDoubleC;
class operator Multiply( const A_:TDoubleC; const B_:Double ) :TDoubleC;
class operator Multiply( const A_:Double; const B_:TDoubleC ) :TDoubleC;
class operator Divide( const A_,B_:TDoubleC ) :TDoubleC;
class operator Divide( const A_:TDoubleC; const B_:Double ) :TDoubleC;
///// 型変換
class operator Implicit( const V_:Double ) :TDoubleC;
end;
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleAreaC
TDoubleAreaC = record
private
///// アクセス
function GetCentR :Double;
procedure SetCentR( const CentR_:Double );
function GetCentI :Double;
procedure SetCentI( const CentI_:Double );
function GetCent :TDoubleC;
procedure SetCent( const Cent_:TDoubleC );
function GetSizeR :Double;
procedure SetSizeR( const SizeR_:Double );
function GetSizeI :Double;
procedure SetSizeI( const SizeI_:Double );
function GetSize :TDoubleC;
procedure SetSize( const Size_:TDoubleC );
public
Min :TDoubleC;
Max :TDoubleC;
/////
constructor Create( const Min_,Max_:TDoubleC ); overload;
constructor Create( const MinR_,MinI_,MaxR_,MaxI_:Double ); overload;
constructor Create( const Cent_:TDoubleC; const SizeR_,SizeI_:Double ); overload;
///// プロパティ
property CentR :Double read GetCentR write SetCentR;
property CentI :Double read GetCentI write SetCentI;
property Cent :TDoubleC read GetCent write SetCent ;
property SizeR :Double read GetSizeR write SetSizeR;
property SizeI :Double read GetSizeI write SetSizeI;
property Size :TDoubleC read GetSize write SetSize ;
end;
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
function Pow2( const X_:TDoubleC ) :TDoubleC; inline; overload;
implementation //############################################################### ■
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleC
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
/////////////////////////////////////////////////////////////////////// アクセス
function TDoubleC.GetAbs2 :Double;
begin
Result := Pow2( R ) + Pow2( I );
end;
function TDoubleC.GetAbso :Double;
begin
Result := Roo2( GetAbs2 );
end;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
constructor TDoubleC.Create( const R_,I_:Double );
begin
R := R_;
I := I_;
end;
///////////////////////////////////////////////////////////////////////// 演算子
class operator TDoubleC.Negative( const V_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := -V_.R;
I := -V_.I;
end
end;
class operator TDoubleC.Positive( const V_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := +V_.R;
I := +V_.I;
end
end;
class operator TDoubleC.Add( const A_,B_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := A_.R + B_.R;
I := A_.I + B_.I;
end
end;
class operator TDoubleC.Subtract( const A_,B_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := A_.R - B_.R;
I := A_.I - B_.I;
end
end;
class operator TDoubleC.Multiply( const A_,B_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := A_.R * B_.R - A_.I * B_.I;
I := A_.R * B_.I + A_.I * B_.R;
end
end;
class operator TDoubleC.Multiply( const A_:TDoubleC; const B_:Double ) :TDoubleC;
begin
with Result do
begin
R := A_.R * B_;
I := A_.I * B_;
end
end;
class operator TDoubleC.Multiply( const A_:Double; const B_:TDoubleC ) :TDoubleC;
begin
with Result do
begin
R := A_ * B_.R;
I := A_ * B_.I;
end
end;
class operator TDoubleC.Divide( const A_,B_:TDoubleC ) :TDoubleC;
var
C :Double;
begin
C := B_.Abs2;
with Result do
begin
R := ( A_.R * B_.R + A_.I * B_.I ) / C;
I := ( A_.I * B_.R - A_.R * B_.I ) / C;
end
end;
class operator TDoubleC.Divide( const A_:TDoubleC; const B_:Double ) :TDoubleC;
begin
with Result do
begin
R := A_.R / B_;
I := A_.I / B_;
end
end;
///////////////////////////////////////////////////////////////////////// 型変換
class operator TDoubleC.Implicit( const V_:Double ) :TDoubleC;
begin
with Result do
begin
R := V_;
I := 0;
end
end;
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleAreaC
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
/////////////////////////////////////////////////////////////////////// アクセス
function TDoubleAreaC.GetCentR :Double;
begin
Result := ( Max.R + Min.R ) / 2;
end;
procedure TDoubleAreaC.SetCentR( const CentR_:Double );
var
S :Double;
begin
S := SizeR / 2;
Min.R := CentR_ - S;
Max.R := CentR_ + S;
end;
function TDoubleAreaC.GetCentI :Double;
begin
Result := ( Max.I + Min.I ) / 2;
end;
procedure TDoubleAreaC.SetCentI( const CentI_:Double );
var
S :Double;
begin
S := SizeI / 2;
Min.I := CentI_ - S;
Max.I := CentI_ + S;
end;
function TDoubleAreaC.GetCent :TDoubleC;
begin
Result := TDoubleC.Create( CentR, CentI );
end;
procedure TDoubleAreaC.SetCent( const Cent_:TDoubleC );
begin
CentR := Cent_.R;
CentI := Cent_.I;
end;
//------------------------------------------------------------------------------
function TDoubleAreaC.GetSizeR :Double;
begin
Result := Max.R - Min.R;
end;
procedure TDoubleAreaC.SetSizeR( const SizeR_:Double );
var
C, S :Double;
begin
C := CentR;
S := SizeR_ / 2;
Min.R := C - S;
Max.R := C + S;
end;
function TDoubleAreaC.GetSizeI :Double;
begin
Result := Max.I - Min.I;
end;
procedure TDoubleAreaC.SetSizeI( const SizeI_:Double );
var
C, S :Double;
begin
C := CentI;
S := SizeI_ / 2;
Min.I := C - S;
Max.I := C + S;
end;
function TDoubleAreaC.GetSize :TDoubleC;
begin
Result := TDoubleC.Create( SizeR, SizeI );
end;
procedure TDoubleAreaC.SetSize( const Size_:TDoubleC );
begin
SizeR := Size_.R;
SizeI := Size_.I;
end;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
constructor TDoubleAreaC.Create( const Min_,Max_:TDoubleC );
begin
Min := Min_;
Max := Max_;
end;
constructor TDoubleAreaC.Create( const MinR_,MinI_,MaxR_,MaxI_:Double );
begin
Create( TDoubleC.Create( MinR_, MinI_ ),
TDoubleC.Create( MaxR_, MaxI_ ) );
end;
constructor TDoubleAreaC.Create( const Cent_:TDoubleC; const SizeR_,SizeI_:Double );
var
S :TDoubleC;
begin
S.R := SizeR_ / 2;
S.I := SizeI_ / 2;
Create( Cent_ - S,
Cent_ + S );
end;
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
function Pow2( const X_:TDoubleC ) :TDoubleC;
begin
Result := X_ * X_;
end;
//############################################################################## □
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
end. //######################################################################### ■
|
unit uLockBox_OpenSSLTestCases;
interface
uses TestFramework, Classes, uTPLb_Signatory, uTPLb_OpenSSL, SysUtils,
uTPLb_Codec, uTPLb_CryptographicLibrary, uTPLb_Random;
type
TOpenSSL_TestCase = class( TTestCase)
protected
FcodecOpenSSL: TOpenSSL_Codec;
FSig: TOpenSSL_Signatory;
FKey, FIV: TBytes;
FBlockSize: integer;
FPlain, FCipher, FRecon: TMemoryStream;
procedure SetUp; override;
procedure TearDown; override;
published
procedure OpenSSL_AES_Encryption;
procedure TwoGenerations;
procedure Signature;
end;
implementation
uses uTPLb_StreamUtils, uTPLb_Constants, uTPLb_Asymetric;
procedure InitUnit_OpenSSLTestCases_TestCases;
begin
TestFramework.RegisterTest( TOpenSSL_TestCase.Suite)
end;
procedure DoneUnit_OpenSSLTestCases_TestCases;
begin
end;
{ TOpenSSL_TestCase }
type
TBlock=array[0..15] of byte;
PBlock=^TBlock;
procedure TOpenSSL_TestCase.OpenSSL_AES_Encryption;
var
I: Integer;
b: byte;
begin
for I := 0 to 7 do
begin
b := i;
FPlain.Write( b, 1);
end;
FPlain.Position := 0;
FcodecOpenSSL.Encrypt( FPlain, FCipher);
FCipher.Position := 0;
FcodecOpenSSL.Decrypt( FRecon, FCipher);
Check( CompareMemoryStreams( FPlain, FRecon), 'Failed general inversion')
end;
procedure TOpenSSL_TestCase.SetUp;
var
i: Integer;
begin
FcodecOpenSSL := TOpenSSL_Codec.Create( nil);
FcodecOpenSSL.RequiredVersion := '0.9.0.0';
FcodecOpenSSL.isLoaded := True;
Check( FcodecOpenSSL.isLoaded, 'Failed to load Libeay32');
FcodecOpenSSL.Cipher := cipher_aes_256_cbc;
FcodecOpenSSL.PaddingScheme := padPKCS;
FBlockSize := 16;
SetLength( FKey, FBlockSize);
SetLength( FIV, FBlockSize);
for i := 0 to FBlockSize - 1 do
begin
FKey[i] := 0;
FIV [i] := 0;
end;
FPlain := TMemoryStream.Create;
FCipher := TMemoryStream.Create;
FRecon := TMemoryStream.Create;
FcodecOpenSSL.SetKey( FKey);
FcodecOpenSSL.SetIV ( FIV);
FSig := TOpenSSL_Signatory.Create( nil);
FSig.RequiredVersion := '0.9.0.0';
FSig.isLoaded := True;
Check( FSig.isLoaded, 'Failed to load Libeay32');
end;
const
PrivateKey1: utf8string =
'-----BEGIN RSA PRIVATE KEY-----'#$A +
'MIIEowIBAAKCAQEAvrcFyDAAU6IyOiXiPaTuAe9CTZtwwLdkDSzb6IzBYwFUH+88'#$A +
'QAklxLlHSsK3P/UKzDScG1bDHa3Ry8LZcU/LmIuFyoPAx5kJEeP5Auk/NGSsFbIw'#$A +
'+bYuMXWU2EVMXhJqQpezJKNc+x03dgZLTBgNuH0E1SO1Reu/4FKYA29zSN5qdYeG'#$A +
'8nrk45e46lm835HYzrDl69IwgB1daZ3/mrvik6qY2JjfiGxHDMqCUtWWuvA6Ayoi'#$A +
'G4EFpU8ej3MElt7kKjJJrx5A4wx+hbr0BzVPWsIoYtffEhTBnEWR3pGe2R1pKy9l'#$A +
'zgklFbp7984gqBOXVigHrRXq0pSdVOhW9ZjSqwIDAQABAoIBADPiDKOiU2RtOqbR'#$A +
'CZRlmw5RrcL5J5p2CbT/4C+Ko02w3db2OXjeRDUZhoiTIlE286IMKe/SEbCwSePZ'#$A +
'9Ve7MpMkWdh3MWnbezkvwN2G4Nf7D0mzuVkls7lm2IBhkd4BuoC1TloIS1JRZ3Yn'#$A +
'TjK8VHc9I6RsW3NTKFb5gTtmBYHr7s/wsptT2QNFmK194AbIGAcb4WWtS34YktDT'#$A +
'gXCdMEqZhASnmShgQhiyL8s5BgacpCBkuVEfBRqrL2MsV2ceSbyuTZUabNFMReOX'#$A +
'BqrGWGbNebFUce1stFhShi9np6cUj3EL1bErC/RZJuXJONDxNEuVutriglInZ9D+'#$A +
'g4vY9YkCgYEA/MtEvlO7ptfaw+9Bb/S+aEFYQTo/C8T0ELV3wW8Pj399OVhmxV8s'#$A +
'ZEUdSYyB6cCJukLPJyGAokSktLBF+sOgxJkGY7dlei9jbUfKa1UGMwKYbxKQX2hA'#$A +
'UGEbRR1Pt/+pNrNgAfMbiwnz+ir5i2gBRXyZvzbfuzs0RbElqpDH7/0CgYEAwSI0'#$A +
'nkMEgOXdm/TBPJUEXLv8AjBlBWjI8KxrefGgZNRBYU64rIiKs68w7Suv4hw77fBj'#$A +
'HIyc1io6W6bOzwx3W9+vEzEG5xHzxcoRESJ0N1195sLuU/F4aCRHioMsSouR02tm'#$A +
'ea4ltqg2DkHSos1ulbnhWxN5/AFu36roAy/A6ccCgYB7WgiKQrt/VzbFgvrQUYGT'#$A +
'x8bz1SMscAeUG6h69+GE6PXGxK8pQh6cMulumSRPVoceHzmL45osFAi2rokHKuxI'#$A +
'4k6u26+lpngCvBQ2uX9T5sFQ+aL/GxS+5BN1by8WHqeILJD9go3/E3U8rjmkX7S3'#$A +
'Hmy7VGBpsSL5ms5BY3JcVQKBgQCdPWkTlMKc4wkLCTkuRrC3g4FIkvgccFRwxh/2'#$A +
't0d77+eO/tWR+tTaN/8giVn4QD52mSlIPB8Qqm664dMsdRzUWwgiGt9gz5fl537/'#$A +
'sUpnLSHs97Wr+EOsniT025j61CkUtTNITAV+cfMYpnSEgbbQBfc4/GFrUAth5LZi'#$A +
'qcVpTwKBgCfrNoD1KB+hWnJoFtFoObzYz/O1dKO7PbxyeMUEV5QLc96emE5W8p9w'#$A +
'8r48LhBgq3Ma2ghmnise9zCaNIjb/DTqoyfD+ZdZat6y+bc2zyWu0tZimSGw5rgs'#$A +
'4XJeUpxr7Gm8p8tS1nUBWmooqiR18ORZEtVxdBAxUl2VRnekYnQG'#$A +
'-----END RSA PRIVATE KEY-----';
procedure TOpenSSL_TestCase.Signature;
var
sSecret: string;
Secret: TStream;
begin
FSig.PrivateKey := PrivateKey1;
FSig.PrivateKeyStoragePassword := 'honey';
FSig.PrivateKeyStorageCipher := cipher_aes_256_cbc;
Secret := TMemoryStream.Create;
FSig.StoreKeysToStream( Secret, [partPrivate]);
Secret.Position := 0;
SetLength( sSecret, Secret.Size);
if Secret.Size > 0 then
Secret.ReadBuffer( sSecret[1], Secret.Size);
Secret.Position := 0;
Check( Pos('-----BEGIN RSA PRIVATE KEY-----', sSecret) > 0, 'OpenSSL key not properly stored.');
Check( Pos('ENCRYPTED', sSecret) > 0, 'OpenSSL key not properly encrypted.');
FSig.LoadKeysFromStream( Secret, [partPrivate]);
Secret.Free;
Check( FSig.SignVerify_SelfTest);
end;
procedure TOpenSSL_TestCase.TearDown;
begin
FcodecOpenSSL.Free;
FPlain.Free;
FCipher.Free;
FRecon.Free;
FSig.Free
end;
procedure TOpenSSL_TestCase.TwoGenerations;
begin
Check( FSig.GenerateKeys);
Check( FSig.GenerateKeys);
end;
initialization
InitUnit_OpenSSLTestCases_TestCases;
finalization
DoneUnit_OpenSSLTestCases_TestCases;
end.
|
unit Main;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes,
System.Variants,
FMX.Types, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.StdCtrls,
FMX.Objects,
FMX.DialogService;
type
TCor = (cAzul = 0, cAmarelo = 1, cBranco = 2);
TJogador = TCor.cAzul .. TCor.cAmarelo;
const
TCorText: array [TCor] of String = ('Azul', 'Amarelo', 'Nenhuma');
TCorJogador: array [TCor] of TAlphaColor = (TAlphaColorRec.Blue,
TAlphaColorRec.Yellow, TAlphaColorRec.White);
Type
TTipoCirculo = record
Cor: TCor;
Utilizado: Boolean;
Circulo: TCircle;
end;
TFMain = class(TForm)
StyleBook1: TStyleBook;
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
FCirculo: Array [1 .. 7, 1 .. 6] of TTipoCirculo;
FJogador: TJogador;
procedure CriarCirulo;
procedure CliqueCirculo(Sender: TObject);
procedure VerificaGanhador(const pX, pY: Integer);
procedure setNovoJogo(const pCor: TCor);
public
{ Public declarations }
end;
implementation
{$R *.fmx}
procedure TFMain.CliqueCirculo(Sender: TObject);
var
lRow, lX: Integer;
begin
if not(Sender is TCircle) then
begin
Exit;
end;
lX := StrToInt(Copy(TCircle(Sender).Name, 2, 1));
for lRow := 6 downto 1 do
begin
if not FCirculo[lX, lRow].Utilizado then
begin
FCirculo[lX, lRow].Utilizado := True;
FCirculo[lX, lRow].Circulo.Fill.Color := TCorJogador[FJogador];
FCirculo[lX, lRow].Cor := FJogador;
FJogador := TCor((ord(FJogador) +1) mod 2 );
VerificaGanhador(lX, lRow);
Break;
end;
if lRow = 1 then
begin
Showmessage('Todos os campos estão em uso, utilize outra coluna.');
end;
end;
end;
procedure TFMain.CriarCirulo;
var
lX, lY: Integer;
begin
for lX := 1 to 7 do
for lY := 1 to 6 do
begin
FCirculo[lX, lY].Utilizado := False;
FCirculo[lX, lY].Cor := cBranco;
FCirculo[lX, lY].Circulo := TCircle.Create(Self);
with FCirculo[lX, lY].Circulo do
begin
Visible := False;
Parent := Self;
Name := 'C' + IntToStr(lX) + IntToStr(lY);
Position.X := (lX - 1) * 50 + (lX) * 10;
Position.Y := (lY - 1) * 50 + (lY) * 10;
Height := 50;
Width := 50;
Tag := 0;
Cursor := crHandPoint;
Fill.Color := TCorJogador[cBranco];
OnClick := CliqueCirculo;
Visible := True;
end;
end;
end;
procedure TFMain.FormCreate(Sender: TObject);
begin
FJogador := cAmarelo;
Self.CriarCirulo;
end;
procedure TFMain.setNovoJogo(const pCor: TCor);
var
lX, lY: Integer;
begin
TDialogService.MessageDialog(TCorText[pCor] + ' Você Ganhou!!!',
TMsgDlgType.mtInformation, [TMsgDlgBtn.mbOK], TMsgDlgBtn.mbOK, 0, nil);
FJogador := cAmarelo;
for lX := 1 to 7 do
for lY := 1 to 6 do
begin
FCirculo[lX, lY].Cor := cBranco;
FCirculo[lX, lY].Utilizado := False;
FCirculo[lX, lY].Circulo.Fill.Color := TAlphaColorRec.White;
end;
end;
procedure TFMain.VerificaGanhador(const pX, pY: Integer);
var
lRow, lRow2, lCountAntes, lCountDepois: Integer;
begin
/// ///////////////////// vertical \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
lCountAntes := 0;
for lRow := pY downto 1 do
if lRow <> pY then
if FCirculo[pX, lRow].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[pX, lRow].Cor) then
inc(lCountAntes)
else
Break;
lCountDepois := 0;
for lRow := pY to 6 do
if lRow <> pY then
if FCirculo[pX, lRow].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[pX, lRow].Cor) then
inc(lCountDepois)
else
Break;
if (lCountAntes + lCountDepois + 1) >= 4 then
begin
Self.setNovoJogo(FCirculo[pX, pY].Cor);
Exit;
end;
/// ///////////////////// horizontal \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
lCountAntes := 0;
for lRow := pX downto 1 do
if lRow <> pX then
if FCirculo[lRow, pY].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow, pY].Cor) then
inc(lCountAntes)
else
Break;
lCountDepois := 0;
for lRow := pX to 7 do
if lRow <> pX then
if FCirculo[lRow, pY].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow, pY].Cor) then
inc(lCountDepois)
else
Break;
if (lCountAntes + lCountDepois + 1) >= 4 then
begin
Self.setNovoJogo(FCirculo[pX, pY].Cor);
Exit;
end;
/// ///////////////////// diagonal 1 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
lCountAntes := 0;
lRow2 := pY - 1;
for lRow := pX downto 1 do
begin
if lRow <= 0 then
Break;
if lRow2 <= 0 then
Break;
if FCirculo[lRow - 1, lRow2].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow - 1, lRow2].Cor) then
inc(lCountAntes)
else
Break;
lRow2 := lRow2 - 1;
end;
lCountDepois := 0;
lRow2 := pY + 1;
for lRow := pX to 7 do
begin
if lRow >= 8 then
Break;
if lRow2 >= 7 then
Break;
if FCirculo[lRow + 1, lRow2].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow + 1, lRow2].Cor) then
inc(lCountDepois)
else
Break;
inc(lRow2);
end;
if (lCountAntes + lCountDepois + 1) >= 4 then
begin
Self.setNovoJogo(FCirculo[pX, pY].Cor);
Exit;
end;
/// ///////////////////// diagonal 2 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
lCountAntes := 0;
lRow2 := pY + 1;
for lRow := pX downto 1 do
begin
if lRow <= 0 then
Break;
if lRow2 >= 7 then
Break;
if FCirculo[lRow - 1, lRow2].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow - 1, lRow2].Cor) then
inc(lCountAntes)
else
Break;
lRow2 := lRow2 + 1;
end;
lCountDepois := 0;
lRow2 := pY - 1;
for lRow := pX to 7 do
begin
if lRow >= 8 then
Break;
if lRow2 <= 0 then
Break;
if FCirculo[lRow + 1, lRow2].Utilizado and
(FCirculo[pX, pY].Cor = FCirculo[lRow + 1, lRow2].Cor) then
inc(lCountDepois)
else
Break;
lRow2 := lRow2 - 1;
end;
if (lCountAntes + lCountDepois + 1) >= 4 then
begin
Self.setNovoJogo(FCirculo[pX, pY].Cor);
Exit;
end;
end;
end.
|
(*
Category: SWAG Title: DIRECTORY HANDLING ROUTINES
Original name: 0051.PAS
Description: Yet Another Tree Program
Author: DAVID DANIEL ANDERSON
Date: 11-22-95 13:33
*)
PROGRAM YATP; { Free DOS utility: Yet Another "Tree" Program. }
(* I got much of the code for this program, particularly
the "DisplayDir" and "ReadFiles" Procedures, from:
╔======================================================╗
║ VTree2 ║
║ Version 1.6, 7-16-90 -- Public Domain by John Land ║
║ (Found in SWAG, in the DIRS library) ║
╚======================================================╝
*)
{$M 32768,0,655360} { Allow a HUGE stack because of heavy recursion. }
{ ┌────────────────────────────────────────────────────┐
│ USES AND GLOBAL VARIABLES & CONSTANTS │
└────────────────────────────────────────────────────┘ }
USES
Crt, DOS;
CONST
NL = #13#10;
NonVLabel = ReadOnly + Hidden + SysFile + Directory + Archive;
LevelMax = 16;
TYPE
FPtr = ^Dir_Rec;
Dir_Rec = RECORD { Double Pointer Record }
DirName : STRING [14];
DirNum : INTEGER;
Next : Fptr;
END;
VAR
Dir : STRING;
Loop,
tooDeep : BOOLEAN;
Level : INTEGER;
Flag : ARRAY [1..LevelMax] OF STRING [2];
Filetotal,
Bytetotal,
Dirstotal : LONGINT;
ColorCnt : WORD;
ClusterSize : WORD;
TotalClusters : LONGINT;
PROCEDURE ShowHelp (CONST problem : BYTE);
(* If any *foreseen* errors arise, we are sent here to
give a little help and exit (relatively) peacefully *)
CONST
progdesc = 'YATP v1.00 - Free DOS utility: Yet Another "Tree" Program.';
author = 'July 3, 1995. Copyright (c) 1995 by David Daniel Anderson - Reign Ware.' + NL;
usage = 'Usage: YATP [drive:][\][directory]' + NL;
notes = 'Notes: All parameters are optional; output may be piped or redirected.' + NL;
examples = 'Examples:' + NL;
examp1 = ' YATP <- all directories below current';
examp2 = ' YATP c:\ <- all directories on drive C:';
examp3 = ' YATP d:\os2\ <- only directories below D:\OS2';
examp4 = ' YATP c:\ | list /s <- pipe C: tree to LIST' + NL;
VAR
message : STRING [50];
BEGIN
WriteLn (progdesc);
WriteLn (author);
WriteLn (usage);
WriteLn (notes);
WriteLn (examples);
WriteLn (examp1);
WriteLn (examp2);
WriteLn (examp3);
WriteLn (examp4);
IF problem > 0 THEN BEGIN
CASE problem OF
1 : message := 'Invalid drive or directory.';
ELSE message := 'Unanticipated error of unknown type.';
END;
WriteLn (#7, message);
END;
Halt (problem)
END;
FUNCTION Format (Num : LONGINT) : STRING; {converts Integer to String}
VAR NumStr : STRING; {& inserts commas as needed}
l : SHORTINT;
BEGIN
Str (Num, NumStr);
l := (Length (NumStr) - 2);
WHILE (l > 1) DO BEGIN
Insert (',', NumStr, l);
Dec (l, 3);
END;
Format := NumStr;
END;
FUNCTION OutputRedirected : BOOLEAN; (* FROM SWAG *)
VAR Regs : REGISTERS; Handle : WORD ABSOLUTE Output;
BEGIN
WITH Regs DO
BEGIN
AX := $4400;
BX := Handle;
MsDos (Regs);
IF DL AND $82 = $82 THEN OutputRedirected := FALSE
ELSE OutputRedirected := TRUE;
END; {With Regs}
END; {OutputRedirected}
PROCEDURE CheckForRedirection;
BEGIN
IF OutputRedirected THEN BEGIN
WriteLn ('YATP output has been redirected.');
Assign (Output, '');
END
ELSE
AssignCrt (Output);
Rewrite (Output);
END;
FUNCTION DirExists (filename: PATHSTR): BOOLEAN;
VAR
Attr : WORD;
f : FILE;
BEGIN
Assign (f, filename);
GetFAttr (f, Attr);
IF (DosError = 0) AND ((Attr AND Directory) = Directory)
THEN DirExists := TRUE
ELSE DirExists := FALSE;
END;
PROCEDURE ReadParameters;
VAR
Param : STRING;
BEGIN
IF (ParamCount < 1) THEN ShowHelp (0);
{Param := STRING (Ptr (PrefixSeg, $0080)^);}
Param := ParamStr(1);
{WHILE (Param [0] > #0) AND (Param [1] = #32) DO Delete (Param, 1, 1);}
IF (Pos ('?', Param) <> 0) OR (Pos ('/', Param) <> 0) THEN ShowHelp (0);
Param := FExpand (Param); { Set Var to param. String }
IF Param [Length (Param) ] = '\' THEN
Dec (Param [0]); { Remove trailing backslash}
Dir := Param;
IF (Length (Param) = 2) AND (Param [2] = ':') THEN
Param := Param + '\'; {add backslash to test ROOT}
IF NOT DirExists (Param) THEN
ShowHelp (1);
END;
FUNCTION GetClusterSize (drive : BYTE): WORD; { SWAG routine }
VAR
regs : REGISTERS;
BEGIN
(*
regs. CX := 0; {set for error-checking just to be sure}
regs. AX := $3600; {get free space}
regs. DX := drive; {0=current, 1=a:, 2=b:, etc.}
MsDos (regs);
getclustersize := regs. AX * regs. CX; {cluster size!}
*)
getclustersize := 0;
END;
PROCEDURE InitGlobalVars;
BEGIN
Dir := ''; { Init. global Vars. }
Loop := TRUE;
Level := 0;
tooDeep := FALSE;
Filetotal := 0;
Bytetotal := 0;
Dirstotal := 1; { Always have a root dir. }
ColorCnt := 1;
IF ParamCount > 0 THEN
ReadParameters { Deal With any params. }
ELSE
GetDir (0, Dir);
TotalClusters := 0;
ClusterSize := (GetClusterSize (Ord (UpCase (Dir [1])) - 64));
{IF ClusterSize = 0
T1HEN ShowHelp (1);}
END;
PROCEDURE DisplayHeader;
BEGIN
WriteLn (' File size Files Directory name');
WriteLn ('===============================================================================');
END;
PROCEDURE CalculateWaste (VAR SR: SEARCHREC);
BEGIN
{IF ((SR. Attr AND Directory) <> Directory)
AND ((SR. Attr AND VolumeID) <> VolumeID)
THEN BEGIN
TotalClusters := TotalClusters + (Sr. Size DIV ClusterSize);
IF ((Sr. Size MOD ClusterSize) <> 0) THEN Inc (TotalClusters, 1);
END;}
END;
PROCEDURE DisplayDir (DirP, DirN : STRING; Levl,
NumSubsVar2, SubNumVar2, NumSubsVar3, NmbrFil : INTEGER;
FilLen : LONGINT);
{NumSubsVar2 is the # of subdirs. in previous level;
NumSumsVar3 is the # of subdirs. in the current level.
DirN is the current subdir.; DirP is the previous path}
CONST
Blank = #32;
VAR
BegLine,
WrtStr,
FlagStr : STRING;
FlagIndex : BYTE;
BEGIN
BegLine := ''; { Init. Variables }
IF Levl > LevelMax THEN
BEGIN
tooDeep := TRUE;
Exit;
END;
IF Levl = 0 THEN { Special handling For }
IF Dir = '' THEN { initial (0) dir. level }
WrtStr := 'ROOT'
ELSE
WrtStr := DirP
ELSE
BEGIN { Level 1+ routines }
IF SubNumVar2 = NumSubsVar2 THEN { if last node in subtree, }
BEGIN { use └─ symbol & set flag }
BegLine := '+-'; { padded With blanks }
Flag [Levl] := Blank + Blank;
END
ELSE { otherwise, use ├─ symbol }
BEGIN { & set flag padded With }
BegLine := '+-'; { blanks }
Flag [Levl] := '|' + Blank;
END;
FlagStr := '';
FOR FlagIndex := 1 TO Levl - 1 DO { Insert │ & blanks as }
FlagStr := FlagStr + Flag [FlagIndex]; { needed, based on level }
BegLine := FlagStr + BegLine;
WrtStr := BegLine + '--' + DirN;
IF (NumSubsVar3 <> 0) THEN { if cur. level has subs }
IF Levl < LevelMax THEN { then change to "T" off }
WrtStr [Length (BegLine) + 1] := '+'
ELSE { if levelMax, special end }
WrtStr := WrtStr + '->'; { to indicate more levels }
END; { end level 1+ routines }
IF Odd (ColorCnt) THEN
TextColor (15)
ELSE
TextColor (9);
Inc (ColorCnt);
WriteLn (Format (FilLen): 22, Format (NmbrFil): 8, '': 3, WrtStr)
{ Write # of Files & Bytes }
END;
PROCEDURE ReadFiles (DirPrev, DirNext : STRING;
SubNumVar1, NumSubsVar1 : INTEGER);
VAR
FileInfo : SEARCHREC;
FileBytes : LONGINT;
NumFiles,
NumSubs : INTEGER;
Dir_Ptr,
CurPtr,
FirstPtr : FPtr;
BEGIN
FileBytes := 0;
NumFiles := 0;
NumSubs := 0;
Dir_Ptr := NIL;
CurPtr := NIL;
FirstPtr := NIL;
IF (DirNext = '') AND (DirPrev [Length (DirPrev) ] = '\') THEN
Dec (DirPrev [0]); { Avoid double backslashes }
IF Loop THEN
FindFirst (DirPrev + DirNext + '\*.*', NonVLabel, FileInfo);
Loop := FALSE; { Get 1st File }
WHILE DosError = 0 DO { Loop Until no more Files }
BEGIN
IF (FileInfo. Name [1] <> '.') THEN
BEGIN
IF ((FileInfo. Attr AND Directory) = Directory) THEN
BEGIN { if fetched File is dir., }
New (Dir_Ptr); { store a Record With dir. }
Dir_Ptr^. DirName := FileInfo. Name; { name & occurence number, }
Inc (NumSubs); { and set links to }
Dir_Ptr^. DirNum := NumSubs; { other Records if any }
IF CurPtr = NIL THEN
BEGIN
Dir_Ptr^. Next := NIL;
CurPtr := Dir_Ptr;
FirstPtr := Dir_Ptr;
END
ELSE
BEGIN
Dir_Ptr^. Next := NIL;
CurPtr^. Next := Dir_Ptr;
CurPtr := Dir_Ptr;
END;
END
ELSE
BEGIN { Tally # of Bytes in File }
FileBytes := FileBytes + FileInfo. Size;
CalculateWaste (FileInfo);
Inc (NumFiles); { Increment # of Files, }
END; { excluding # of subdirs. }
END;
FindNext (FileInfo); { Get next File }
END; {end While}
Bytetotal := Bytetotal + FileBytes;
Filetotal := Filetotal + NumFiles;
Dirstotal := Dirstotal + NumSubs;
DisplayDir (DirPrev, DirNext, Level, NumSubsVar1, SubNumVar1,
NumSubs, NumFiles, FileBytes); { Pass info to & call }
Inc (Level); { display routine, & inc. }
{ level number }
WHILE (FirstPtr <> NIL) DO { if any subdirs., then }
BEGIN { recursively loop thru }
Loop := TRUE; { ReadFiles proc. til done }
ReadFiles ((DirPrev + DirNext + '\'), FirstPtr^. DirName,
FirstPtr^. DirNum, NumSubs);
FirstPtr := FirstPtr^. Next;
END;
{ Decrement level when }
Dec (Level); { finish a recursive loop }
{ call to lower level of }
END; { subdir. }
PROCEDURE WriteDriveInfo;
VAR DS, DF : LONGINT; {bytes of *partition* space Size/Free}
Disk : BYTE;
Percent : STRING[6];
BEGIN
Disk := (Ord (UpCase (Dir [1])) - 64);
DS := DiskSize (Disk);
IF (DS < 0) THEN BEGIN
DS := 0;
DF := 0;
END
ELSE
DF := DiskFree (Disk);
IF DS = 0
THEN Percent := ('0.00')
ELSE Str ((100 * (DF / DS)): 0: 2, Percent);
WriteLn ('Free: ', Format (DF): 15,
' bytes out of ', Format (DS),
' (', percent, '% of drive is unused)');
END;
PROCEDURE DisplayTally;
VAR
WasteSpace,
TotalSpace : LONGINT;
BEGIN
WriteLn ('===============================================================================');
WriteLn ('Totals:', Format (Bytetotal): 15, Format (Filetotal): 8, '(': 4, Dirstotal, ' directories)');
TotalSpace := (TotalClusters * ClusterSize);
WasteSpace := (TotalSpace - Bytetotal);
{WriteLn ('Using: ', Format (TotalSpace): 15,
' bytes altogether (based on ', ClusterSize, ' bytes per cluster)');
Write ('Making:', Format (WasteSpace): 15, ' bytes wasted (');}
{IF Bytetotal = 0
THEN Write ('0.00')
ELSE Write (100 * (WasteSpace / TotalSpace): 0: 2);
WriteLn ('% of the space used is wasted)');}
WriteDriveInfo;
END;
{ ┌────────────────────────────────────────────────────┐
│ Main Program │
└────────────────────────────────────────────────────┘ }
BEGIN
ClrScr;
CheckForRedirection; { Get ready ... }
InitGlobalVars; { Get set ... }
TextColor (Cyan);
DisplayHeader; { Display Header }
ReadFiles (Dir, '', 0, 0); { Go! do main read routine }
TextColor (Cyan);
DisplayTally; { Display totals }
IF tooDeep THEN
WriteLn (NL, NL, '': 21, '» CANNOT DISPLAY MORE THAN ', LevelMax, ' LEVELS «', NL);
{ if ReadFiles detects > 16}
{ levels, tooDeep flag set }
END. { Finish. }
{
YATP v1.00
DOS utility: Yet Another "Tree" Program
Freeware, copyright (c) July 3, 1995
by
David Daniel Anderson
Reign Ware
** READ REIGNWAR.TXT FOR LEGAL TERMS **
YATP is Yet Another "Tree" Program. YATP displays the directory structure
of the drive and/ or directory that you specify, or if none is specified,
the drive and directory structure of the current directory is displayed.
Usage: YATP [drive:][\][directory]
Notes: All parameters are optional; output may be piped or redirected.
Examples:
YATP <- all directories below current
YATP c:\ <- all directories on drive C:
YATP d:\os2\ <- only directories below D:\OS2
YATP c:\ | list /s <- pipe C: tree to LIST
Enter "YATP ?" to display this short reminder of the syntax.
** READ REIGNWAR.TXT FOR LEGAL TERMS **
}
|
(*
Category: SWAG Title: DIRECTORY HANDLING ROUTINES
Original name: 0005.PAS
Description: Searching a Complete Drv
Author: SWAG SUPPORT TEAM
Date: 05-28-93 13:37
*)
{
> Can any one tell me a way to make pascal (TP 6.0) search a Complete
> drive, including all subdirectories, even ones that are not in the
> path, looking For a specific File extension? I.E., having the Program
> search For *.doC and saving that to a Text File?
Ok, here goes nothing.
}
Program FindAllFiles;
Uses Dos;
Procedure ScanDir(path : PathStr; var outputFile : text);
Var
SearchFile : SearchRec;
begin
writeln('Examining: '+path);
if Path[Length(Path)] <> '\' then
Path := Path + '\';
FindFirst(Path + '*.*', $37, SearchFile); { Find Files and Directories }
While DosError = 0 do { While There are more Files }
begin
if ((SearchFile.Attr and $10) = $10) and (SearchFile.Name[1] <> '.') then
ScanDir(Path + SearchFile.Name, outputFile)
{ Found a directory Make sure it's not . or .. Scan this dir also }
else
if Pos('.doc',SearchFile.Name)>0 then
Writeln(outputFile, Path + SearchFile.Name);
{ if the .doC appears in the File name, Write path to File. }
FindNext(SearchFile);
end;
end;
Var
outputFile : Text;
begin
Assign(outputFile,'docs.txt'); { File to contain list of .doCs }
ReWrite(outputFile);
ScanDir('D:\', outputFile); { Drive to scan. }
Close(outputFile);
end.
|
unit ThStylePainter;
interface
uses
Windows, Types, Graphics,
ThCssStyle;
type
TThStylePainter = class
private
FPaintRect: TRect;
FCanvas: TCanvas;
FStyle: TThCssStyle;
FColor: TColor;
protected
procedure PaintRectEdge(inStyle: TPenStyle; inWidth: Integer;
inSide: TThCssBorderSide);
procedure PaintDotEdge(inWidth: Integer; inSide: TThCssBorderSide);
procedure PaintDashEdge(inWidth: Integer; inSide: TThCssBorderSide);
procedure PaintBorder(inSide: TThCssBorderSide);
procedure Borders4(inSide: TThCssBorderSide; inL, inT, inR,
inB: TColor);
public
constructor Create;
procedure PaintBackground;
procedure PaintBorders;
procedure PaintColorBackground;
procedure PaintInsetBorders;
procedure PaintOutsetBorders;
procedure PaintPictureBackground;
procedure Prepare(inColor: TColor; inStyle: TThCssStyle; inCanvas: TCanvas;
const inRect: TRect);
public
property Color: TColor read FColor write FColor;
property Canvas: TCanvas read FCanvas write FCanvas;
property PaintRect: TRect read FPaintRect write FPaintRect;
property Style: TThCssStyle read FStyle write FStyle;
end;
var
StylePainter: TThStylePainter;
implementation
uses
ThGraphicUtils;
function TbhMax(inA, inB: Integer): Integer;
begin
if inA >= inB then
Result := inA
else
Result := inB;
end;
function TbhGetRectEdge(const inRect: TRect;
inSide: TThCssBorderSide; inWidth: Integer = 0): TRect;
begin
with inRect do
case inSide of
bsLeft:
Result := Rect(Left, Top, Left, Bottom-1);
bsTop:
Result := Rect(Left, Top, Right-1, Top);
bsRight:
Result := Rect(Right-inWidth-1, Top, Right-inWidth-1, Bottom-1);
bsBottom:
Result := Rect(Left, Bottom-inWidth-1, Right, Bottom-inWidth-1);
end;
end;
procedure TbhInflateBySide(var ioRect: TRect; inD: Integer;
inSide: TThCssBorderSide);
begin
case inSide of
bsLeft, bsRight: InflateRect(ioRect, inD, 0);
bsTop, bsBottom: InflateRect(ioRect, 0, inD);
end;
end;
constructor TThStylePainter.Create;
begin
Color := clDefault;
end;
procedure TThStylePainter.PaintDotEdge(inWidth: Integer;
inSide: TThCssBorderSide);
var
r: TRect;
x, y, dx, dy: Single;
l, c, i: Integer;
begin
r := PaintRect;
InflateRect(r, -inWidth div 2, -inWidth div 2);
r := TbhGetRectEdge(r, inSide);
x := r.Left;
dx := r.Right - x;
y := r.Top;
dy := r.Bottom - y;
l := TbhMax(Round(dx), Round(dy));
c := l div (inWidth + inWidth);
dx := dx / c;
dy := dy / c;
with Canvas do
begin
Pen.Style := psSolid;
Pen.Width := inWidth;
for i := 0 to c do
begin
MoveTo(Round(x), Round(y));
LineTo(Round(x)+1, Round(y));
x := x + dx;
y := y + dy;
end;
end;
end;
procedure TThStylePainter.PaintDashEdge(inWidth: Integer;
inSide: TThCssBorderSide);
const
cDash = 6;
cSpace = 3;
cBolt = cDash + cSpace;
var
r: TRect;
x, y, dx, dy: Single;
d, s, b: Integer;
l, c, i, wx, wy: Integer;
begin
r := PaintRect;
Inc(r.Bottom);
Inc(r.Right);
r := TbhGetRectEdge(r, inSide, inWidth);
//
x := r.Left;
y := r.Top;
dx := r.Right - x;
dy := r.Bottom - y;
//
d := inWidth * 2;
if (d < 4) then
d := 4;
s := d div 2;
b := d + s;
//
l := TbhMax(Round(dx), Round(dy)) + s;
c := (l + b div 2) div b;
//
if (dx < dy) then
begin
wx := inWidth;
wy := d;
dx := 0;
dy := l / c;
end
else begin
wx := d;
wy := inWidth;
dx := l / c;
dy := 0;
end;
//
with Canvas do
begin
for i := 0 to c do
begin
FillRect(Rect(Round(x), Round(y), Round(x) + wx, Round(y) + wy));
x := x + dx;
y := y + dy;
end;
end;
end;
procedure TThStylePainter.PaintRectEdge(inStyle: TPenStyle; inWidth: Integer;
inSide: TThCssBorderSide);
var
i: Integer;
e, r: TRect;
begin
with Canvas do
begin
r := PaintRect;
Pen.Style := inStyle;
for i := 1 to inWidth do
begin
e := TbhGetRectEdge(r, inSide);
MoveTo(e.Left, e.Top);
LineTo(e.Right, e.Bottom);
TbhInflateBySide(r, -1, inSide);
end;
end;
end;
procedure TThStylePainter.PaintBorder(inSide: TThCssBorderSide);
var
w, wp, wx: Integer;
c: TColor;
begin
with Style.Border, Canvas do
begin
c := GetBorderColor(inSide);
Pen.Color := c;
Brush.Color := c;
w := GetBorderPixels(inSide);
case GetBorderStyle(inSide) of
//
bsSolidBorder: PaintRectEdge(psSolid, w, inSide);
//
bsDotted: PaintDotEdge(w, inSide);
//
bsDashed: PaintDashEdge(w, inSide);
//
bsDouble:
begin
wp := w div 3;
wx := w - wp * 3;
if (wp < 0) then
PaintRectEdge(psSolid, w, inSide)
else begin
PaintRectEdge(psSolid, wp, inSide);
TbhInflateBySide(FPaintRect, -wp - wp - wx, inSide);
PaintRectEdge(psSolid, wp, inSide);
end;
end;
//
end;
Pen.Width := 1;
end;
end;
procedure TThStylePainter.Borders4(inSide: TThCssBorderSide;
inL, inT, inR, inB: TColor);
var
r: TRect;
begin
with Canvas.Pen do
case inSide of
bsLeft, bsTop: Color := inL;
else Color := inT;
end;
r := PaintRect;
PaintRectEdge(psSolid, 1, inSide);
InflateRect(FPaintRect, -1, -1);
with Canvas.Pen do
case inSide of
bsLeft, bsTop: Color := inR;
else Color := inB;
end;
PaintRectEdge(psSolid, 1, inSide);
PaintRect := r;
end;
procedure TThStylePainter.PaintInsetBorders;
var
i: TThCssBorderSide;
begin
for i := bsLeft to bsBottom do
case Style.Border.GetBorderStyle(i) of
bsDefault: Borders4(i, clBlack, $EEEEEE, clBtnShadow, Color)
else PaintBorder(i);
end;
end;
procedure TThStylePainter.PaintOutsetBorders;
var
i: TThCssBorderSide;
begin
for i := bsLeft to bsBottom do
case Style.Border.GetBorderStyle(i) of
bsDefault: Borders4(i, clWhite, clBtnShadow, $EEEEEE, clBlack)
else PaintBorder(i);
end;
end;
procedure TThStylePainter.PaintBorders;
var
i: TThCssBorderSide;
begin
for i := bsLeft to bsBottom do
PaintBorder(i);
end;
procedure TThStylePainter.PaintPictureBackground;
begin
if Style.Background.Picture.HasGraphic then
ThTileGraphic(Canvas, PaintRect,
Style.Background.Picture.PictureData.Graphic)
end;
procedure TThStylePainter.PaintColorBackground;
begin
//if ThVisibleColor(Style.Color) then
if ThVisibleColor(Color) then
with Canvas do
begin
Brush.Color := Color;
FillRect(PaintRect);
end;
end;
procedure TThStylePainter.PaintBackground;
begin
if Style.Background.Picture.HasGraphic then
PaintPictureBackground
else
PaintColorBackground;
end;
procedure TThStylePainter.Prepare(inColor: TColor; inStyle: TThCssStyle;
inCanvas: TCanvas; const inRect: TRect);
begin
Color := inColor;
Style := inStyle;
Canvas := inCanvas;
PaintRect := inRect;
end;
initialization
StylePainter := TThStylePainter.Create;
finalization
StylePainter.Free;
end.
|
unit uModel115ProgramSettings;
interface
uses
SysUtils, IniFiles, Forms, Dutils;
Type
TMode = ( Batch, Interactive );
var
lf: TextFile;
fini : TiniFile;
LogFileName, IniFileName, InitialCurrentDir: TFileName;
Mode: TMode;
implementation
initialization
InitialCurrentDir := GetCurrentDir;
LogFileName := ChangeFileExt( Application.ExeName, '.log' );
IniFileName := ChangeFileExt( Application.ExeName, '.ini' );
Mode := Interactive;
with FormatSettings do begin {-Delphi XE6}
DecimalSeparator := '.';
end;
Application.ShowHint := True;
AssignFile( lf, LogFileName ); Rewrite( lf );
fini := TIniFile.Create( IniFileName );
Writeln( lf, Format( DateTimeToStr(Now) + ': ' + 'Starting application: [%s].', [Application.ExeName] ) );
finalization
Writeln( lf, Format( DateTimeToStr(Now) + ': ' +'Closing application: [%s].', [Application.ExeName] ) );
fini.Free;
CloseFile( lf );
SetCurrentDir( InitialCurrentDir );
end.
|
{
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Author: PeratX
* Genisys-Android Project
}
Program Genisys_Android;
{$mode objfpc}
Uses dos,sysutils;
Const
PROG_VER: string = 'v0.2.8 alpha';
SHELL: string = '/system/bin/sh';
Var
HOME: string;
WORKSPACE: string = '/sdcard/Genisys/';
Procedure testPerm;
Var
t: text;
Begin
Try
assign(t,HOME+'settings.conf');
reset(t);
close(t);
Except
on EInOutError Do
Begin
writeln('[ERROR] Unable to access '+HOME+'settings.conf : Permission denied !');
halt;
End;
Else
Begin
writeln('[ERROR] Unable to access '+HOME+'settings.conf : Unknown error');
halt;
End;
End;
End;
Procedure execBusybox(cmd:String;needLine:boolean = true);
Begin
exec(HOME+'busybox', cmd);
If needLine Then writeln;
End;
Procedure execPhp(homedir,fileName:String);
Var t: text;
Begin
execBusybox('chmod 777 '+HOME+'php');//Set Perm
assign(t,HOME+'temp.sh');
rewrite(t);
writeln(t,'cd '+WORKSPACE);
writeln(t,'export TMPDIR='+WORKSPACE+'tmp');
writeln(t,HOME+'php '+fileName);
close(t);
exec(SHELL, HOME+'temp.sh');
erase(t);
End;
Procedure pause;
Begin
write('Press enter to continue ...');
readln;
End;
Procedure throwError(str:String);
Begin
writeln;
//textcolor(12);
writeln('[ERROR] '+str);
writeln;
pause;
// execBusybox('sleep 1');
End;
Procedure initRuntimeFromZip(fileName:String);
Begin
execBusybox('unzip -o '+fileName+' -d '+HOME);
End;
Procedure initCoreFromZip(fileName:String);
Begin
execBusybox('unzip -o '+fileName+' -d '+WORKSPACE);
End;
Procedure writeDefaultWorkspace;
Var t: text;
Begin
assign(t,HOME+'settings.conf');
rewrite(t);
writeln(t,'/sdcard/Genisys/');
close(t);
End;
Procedure initWorkspace;
Var t: text;
Begin
If Not fileExists(HOME+'settings.conf') Then
Begin
writeDefaultWorkspace;
End;
assign(t,HOME+'settings.conf');
reset(t);
readln(t,WORKSPACE);
If Not fileExists(WORKSPACE) Then
Begin
throwError('Workspace not found, use /sdcard/Genisys/ as default');
writeDefaultWorkspace;
WORKSPACE := '/sdcard/Genisys/';
End;
close(t);
End;
Procedure saveWorkspace(dir:String);
Var t: text;
Begin
If (dir[length(dir)] <> '/') Then dir := dir+'/';
WORKSPACE := dir;
assign(t,HOME+'settings.conf');
rewrite(t);
writeln(t,dir);
close(t);
End;
Procedure initPhpConf(force:boolean = false);
Var t: text;
Begin
If force Or Not fileExists(HOME+'php.ini') Then
Begin
assign(t,HOME+'php.ini');
rewrite(t);
writeln(t,'date.timezone=CDT');
writeln(t,'short_open_tag=0');
writeln(t,'asp_tags=0');
writeln(t,'phar.readonly=0');
writeln(t,'phar.require_hash=1');
close(t);
End;
End;
Procedure textcolor(int:longint);
Begin;
End;
//usage of CRT unit will cause format errors
{
procedure writeVersion;
var t:text;
begin
assign(t,HOME+'ver.txt');rewrite(t);
writeln(t,PROG_VER);
close(t);
end;
procedure updateExecutable;
begi
procedure checkUpdate;
var
t:text;
ver:string;
begin
if not fileExists(HOME+'ver.txt') then begin
updateExeutable;
exit;
end else begin
assign(t,HOME+'ver.txt');reset(t);
readln(ver);
if ver <> PROG_VRR then begin
updateExecutable;
exit;
end;
end;
end;
}
Procedure main;
Var opt: string;
Begin
HOME := extractFilePath(paramStr(0));
//Auto detect working home
testPerm;
initWorkspace;
initPhpconf;
//checkUpdate;
//writeVersion;
execBusybox('rm '+paramStr(0));
execBusybox('mkdir '+WORKSPACE, false);
execBusybox('mkdir '+WORKSPACE+'tmp', false);
execBusybox('clear');
textcolor(11);
//AQUA
writeln('Genisys Android '+PROG_VER);
textcolor(13);
//PURPLE
writeln('Powered by iTX Technologies');
writeln;
writeln('Home: '+HOME);
writeln('Workspace: '+WORKSPACE);
writeln;
textcolor(15);
//WHITE
writeln('a. Init Genisys Android from zips');
// writeln;
textcolor(6);
//YELLOW
writeln('[NOTICE] Put php.zip and Genisys.zip into '+WORKSPACE);
// writeln;
textcolor(15);
writeln('b. Launch Genisys');
// writeln;
writeln('c. Set workspace');
// writeln;
writeln('d. Edit php.ini');
writeln('[NOTICE] Please edit before launch Genisys');
// writeln;
writeln('e. Rewrite php.ini');
writeln;
writeln('i. About Genisys Android');
writeln;
write('Select: ');
readln(opt);
If opt = 'a' Then
Begin
initRuntimeFromZip(WORKSPACE+'php.zip');
initCoreFromZip(WORKSPACE+'Genisys.zip');
writeln;
writeln('Done!');
writeln;
pause;
main;
exit;
End
Else If opt = 'b' Then
Begin
If Not fileExists(HOME+'php') Then
Begin
throwError('Php runtime has not been installed !');
main;
exit;
End;
writeln;
writeln('[NOTICE] Now loading ...');
If fileExists(WORKSPACE+'Genisys.phar') Then execPhp(WORKSPACE, 'Genisys.phar')
Else If fileExists(WORKSPACE+'src/pocketmine/PocketMine.php') Then execPhp(WORKSPACE, 'src/pocketmine/PocketMine.php')
Else throwError('Genisys has not been installed !');
writeln;
pause;
main;
exit;
End
Else If opt = 'c' Then
Begin
write('Please enter the full path of workspace ['+WORKSPACE+'] ');
readln(WORKSPACE);
If WORKSPACE = '' Then
Begin
writeln;
writeln('[INFO] Workspace has not changed');
writeln;
pause;
main;
exit;
End
Else
If Not fileExists(WORKSPACE) Then
Begin
throwError(WORKSPACE+' does not exist');
writeln;
pause;
main;
exit;
End
Else
Begin
saveWorkspace(WORKSPACE);
writeln('[INFO] Workspace has changed to '+WORKSPACE);
writeln;
pause;
main;
exit;
End;
End
Else If opt = 'd' Then
Begin
execBusybox('vi '+HOME+'php.ini');
pause;
main;
exit;
End
Else If opt = 'i' Then
Begin
execBusybox('clear');
writeln('Genisys Android');
writeln('Version: '+PROG_VER);
writeln('Github repo: https://github.com/iTXTech/Genisys-Android');
writeln;
writeln('This application itself is based on Terminal Emulator for Android by jackpal.');
writeln('This program is made by PeratX.');
writeln('Genisys is made by iTX Technologies.');
writeln('Genisys is a server software for Minecraft: Pocket Edition, which is based on the great project "PocketMine-MP".');
writeln;
writeln('Author: PeratX');
writeln('QQ: 1215714524');
writeln('E-mail: 1215714524@qq.com');
writeln;
pause;
main;
exit;
End
Else If opt = 'e' Then
Begin
initPhpConf(true);
writeln;
writeln('Done');
writeln;
pause;
main;
exit;
End
Else
Begin
throwError('Option not found !');
main;
exit;
End;
End;
Begin
If paramcount = 0 Then main
Else If paramstr(1) = '-v' Then writeln(PROG_VER);
End.
|
{* Extended Backus-Naur Form for RawrLang, a F#-based programming language with
the Haskell typesystem which compiles to PHP *}
module = "module", identifier, "where" ;
identifier = ( letter | "'" ), { letter | "'" | digit } ;
letter = uppercase-letter | lowercase-letter ;
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
uppercase-letter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J"
| "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T"
| "U" | "V" | "W" | "X" | "Y" | "Z" ;
lowercase-letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j"
| "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t"
| "u" | "v" | "w" | "x" | "y" | "z" ;
{* -- Usage and tests -- *}
module Register where
class Main [args :: Str] where
method construct where
("Hello World!" :: Str).putStrLn!
end
end
|
unit uServerDatabase;
interface
uses
System.Classes, System.StrUtils, System.SysUtils, uDBUtils, uModApp, System.Rtti,
System.TypInfo;
type
TServerDatabase = class(TObject)
protected
function GenerateCreateTable(AModAPP : TModApp): string; virtual; abstract;
function GenerateAlterTable(AModAPP : TModApp): string; virtual; abstract;
public
function CreateTableSQLByClassName(AClassName : String): string; overload;
function CreateTableSQLByUnitName(AUnitName : String): string; overload;
function GenerateSQLCreateTable(AModAPP : TModApp): string;
function IsFieldNameExist(ATableName : String; AFieldName : String): Boolean;
virtual; abstract;
function IsTableExist(ATableName : String): Boolean; virtual; abstract;
end;
TServerDatabaseSQLServer = class(TServerDatabase)
protected
function GenerateAlterTable(AModAPP : TModApp): string; override;
function AlterAddTable(AModAPP : TModApp): string;
function AlterDropColumn(AModAPP: TModApp): string;
function GenerateCreateTable(AModAPP : TModApp): string; override;
public
function IsFieldNameExist(ATableName : String; AFieldName : String): Boolean;
override;
function IsPropertyExist(AFieldName : String; AModApp : TModApp): Boolean;
function IsTableExist(ATableName : String): Boolean; override;
end;
implementation
function TServerDatabaseSQLServer.GenerateAlterTable(AModAPP : TModApp): string;
begin
Result := AlterAddTable(AModAPP);
Result := Result + AlterDropColumn(AModAPP);
end;
function TServerDatabaseSQLServer.AlterAddTable(AModAPP : TModApp): string;
var
ctx : TRttiContext;
rt : TRttiType;
prop : TRttiProperty;
UpdateVal : string;
FieldName : String;
begin
UpdateVal := '';
rt := ctx.GetType(AModAPP.ClassType);
for prop in rt.GetProperties do
begin
If prop.Visibility <> mvPublished then continue;
FieldName := AModAPP.FieldNameOf(prop);
if IsFieldNameExist(AModAPP.GetTableName, FieldName) then
Continue
else begin
If UpdateVal <> '' then UpdateVal := UpdateVal + ',';
UpdateVal := UpdateVal + FieldName + ' ' + AModAPP.GetSQLServerFieldType(prop)
end;
end;
if UpdateVal <> '' then
begin
Result := Format(SQL_Alter,[AModAPP.GetTableName,UpdateVal]);
Result := UpperCase(Result);
end;
end;
function TServerDatabaseSQLServer.AlterDropColumn(AModAPP: TModApp): string;
var
sSQL: string;
begin
Result := '';
sSQL := 'SELECT col.name ' +
' from sys.tables as tbl ' +
' INNER JOIN sys.columns col ON col.object_id=tbl.object_id ' +
' inner join sys.types typ on col.system_type_id = typ.system_type_id ' +
' WHERE tbl.Name= ' + QuotedStr(AModAPP.GetTableName);
with TDBUtils.OpenQuery(sSQL) do
begin
try
while not Eof do
begin
if not IsPropertyExist(FieldByName('name').AsString, AModAPP) then
begin
Result := Result + 'alter table ' + AModAPP.GetTableName + ' drop column ' + FieldByName('name').AsString + ';';
end;
Next;
end;
finally
Free;
end;
end;
end;
function TServerDatabaseSQLServer.GenerateCreateTable(AModAPP : TModApp):
string;
var
ctx : TRttiContext;
rt : TRttiType;
prop : TRttiProperty;
UpdateVal : string;
FieldName : String;
begin
UpdateVal := '';
rt := ctx.GetType(AModAPP.ClassType);
for prop in rt.GetProperties do
begin
// if UpperCase(prop.Name) = 'ID' then continue;
If prop.Visibility <> mvPublished then continue;
FieldName := AModAPP.FieldNameOf(prop);
If UpdateVal <> '' then UpdateVal := UpdateVal + ',';
UpdateVal := UpdateVal + FieldName + ' ' + AModAPP.GetSQLServerFieldType(prop)
end;
Result := Format(SQL_Create,[AModAPP.GetTableName,UpdateVal]);
Result := UpperCase(Result);
end;
function TServerDatabaseSQLServer.IsFieldNameExist(ATableName : String;
AFieldName : String): Boolean;
var
sSQL: string;
begin
Result := False;
sSQL := 'SELECT count(tbl.name) as Jml from sys.tables as tbl ' +
' INNER JOIN sys.columns col ON col.object_id=tbl.object_id' +
' inner join sys.types typ on col.system_type_id = typ.system_type_id' +
' WHERE tbl.Name= ' + QuotedStr(ATableName) +
' and col.name = ' + QuotedStr(AFieldName);
with TDBUtils.OpenQuery(sSQL) do
begin
try
if FieldByName('Jml').AsInteger > 0 then
Result := True;
finally
Free;
end;
end;
end;
function TServerDatabaseSQLServer.IsPropertyExist(AFieldName : String; AModApp
: TModApp): Boolean;
var
ctx : TRttiContext;
rt : TRttiType;
prop : TRttiProperty;
begin
Result := False;
rt := ctx.GetType(AModAPP.ClassType);
for prop in rt.GetProperties do
begin
If prop.Visibility <> mvPublished then continue;
if UpperCase(AModAPP.FieldNameOf(prop)) = UpperCase(AFieldName) then
begin
Result := True;
Exit;
end;
end;
end;
function TServerDatabaseSQLServer.IsTableExist(ATableName : String): Boolean;
var
sSQL: string;
begin
Result := False;
sSQL := 'select COUNT(a.name) as Jml' +
' from sys.tables a ' +
' where a.name = ' + QuotedStr(ATableName);
with TDBUtils.OpenQuery(sSQL) do
begin
try
if FieldByName('Jml').AsInteger > 0 then
Result := True;
finally
Free;
end;
end;
end;
function TServerDatabase.CreateTableSQLByClassName(AClassName : String): string;
var
AObject: TObject;
C : TRttiContext;
begin
AObject := (C.FindType(AClassName) as TRttiInstanceType).MetaClassType.Create;
Result := GenerateSQLCreateTable(TModApp(AObject));
end;
function TServerDatabase.CreateTableSQLByUnitName(AUnitName : String): string;
var
AObject: tobject;
C: TRttiContext;
t: TRttiType;
DeclaringUnitName: string;
// sClassName: string;
begin
Result := '';
for t in C.GetTypes do
begin
if t.IsInstance then
begin
DeclaringUnitName := t.AsInstance.DeclaringUnitName;
if SameText(DeclaringUnitName, AUnitName) then
begin
AObject := (C.FindType(AUnitName + '.' + t.ToString) as TRttiInstanceType).MetaClassType.Create;
if Result = '' then
Result := GenerateSQLCreateTable(TModApp(AObject))
else
Result := Result + GenerateSQLCreateTable(TModApp(AObject));
end;
end;
end;
end;
function TServerDatabase.GenerateSQLCreateTable(AModAPP : TModApp): string;
begin
if not IsTableExist(AModAPP.GetTableName) then
Result := GenerateCreateTable(AModAPP)
else
Result := GenerateAlterTable(AModAPP);
end;
end.
|
unit fmeSelectPartition;
interface
// NOTE: The "Tabs" property of the TTabControl has the tab captions as it's
// strings (as per normal), but each of the TStringList's Object's is a
// DWORD.
// If the DWORD's highest WORD is HIWORD_CDROM, the lowest WORD is an
// index into FRemovableDevices
// If the DWORD's highest WORD is HIWORD_DISK, the lowest WORD is a disk
// number
// NOTE: This frame can act "oddly" if it's put on a TTabSheet; controls set
// as "Visible := FALSE" were being set to non-visible, but were still
// visible on the display. To fix this, the code segment marked
// "[TAB_FIX]" in this source was put in, which seems to cure things
// PROVIDED THAT Initialize(...) is called after the tab is selected for
// the first time.
// THIS *SHOULDN'T* BE NEEDED - but is!!!
uses
ActnList, Classes, ComCtrls,
Controls, Dialogs, ExtCtrls, fmeDiskPartitionsPanel, fmeSDUBlocks, fmeSDUDiskPartitions, Forms,
Graphics, ImgList, Menus, Messages, OTFEFreeOTFEBase_U,
SDUGeneral, StdCtrls, SysUtils, Variants, Windows;
type
TfmeSelectPartition = class (TFrame)
TabControl1: TTabControl;
pnlNoPartitionDisplay: TPanel;
ckShowCDROM: TCheckBox;
ckEntireDisk: TCheckBox;
lblErrorWarning: TLabel;
ilErrorWarning: TImageList;
imgErrorWarning: TImage;
PopupMenu1: TPopupMenu;
ActionList1: TActionList;
actProperties: TAction;
Properties1: TMenuItem;
SDUDiskPartitionsPanel1: TfmeDiskPartitionsPanel;
procedure TabControl1Change(Sender: TObject);
procedure ckShowCDROMClick(Sender: TObject);
procedure ckEntireDiskClick(Sender: TObject);
procedure SDUDiskPartitionsPanel1Changed(Sender: TObject);
procedure actPropertiesExecute(Sender: TObject);
procedure FrameResize(Sender: TObject);
private
FAllowCDROM: Boolean;
FOnChange: TNotifyEvent;
FRemovableDevices: TStringList;
function GetSelectedDevice(): String;
procedure SetPartitionDisplayDisk(diskNo: Integer);
procedure SetAllowCDROM(allow: Boolean);
procedure ShowPartitionControl();
function GetSyntheticDriveLayout(): Boolean;
procedure PopulateTabs();
procedure NotifyChanged(Sender: TObject);
procedure UpdateErrorWarning();
procedure CenterErrorWarning();
procedure EnableDisableControls();
function IsCDROMTabSelected(): Boolean;
procedure SelectionErrorWarning(var msg: String; var isWarning: Boolean; var isError: Boolean);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy(); override;
procedure Initialize();
function SelectedSize(): ULONGLONG;
published
property SelectedDevice: String Read GetSelectedDevice;
property AllowCDROM: Boolean Read FAllowCDROM Write SetAllowCDROM default True;
property OnChange: TNotifyEvent Read FOnChange Write FOnChange;
property SyntheticDriveLayout: Boolean Read GetSyntheticDriveLayout;
end;
implementation
{$R *.dfm}
uses
GraphUtil, // Required for GetHighLightColor(...)
SDUDiskPropertiesDlg,
SDUi18n,
SDUPartitionPropertiesDlg;
const
COLOR_USABLE = TColor($00C000); // clLime too bright, clGreen too dark
COLOR_UNUSABLE = TColor($0000E0); // clRed too bright
// Bitmask - these go up 1, 2, 4, 8, 16, 32, etc in the hi-word
HIWORD_DISK = $00010000;
HIWORD_CDROM = $00020000;
HIWORD_OTHER = $00040000;
HIWORD_etc = $00080000;
// Images indexes within ilErrorWarning
ICON_NONE = 0;
ICON_WARNING = 1;
ICON_ERROR = 2;
resourcestring
RS_NO_PARTITIONS_FOUND = '<No partitions found>';
RS_CANT_GET_DISK_LAYOUT = '<Unable to get disk layout information for disk #%1>';
RS_ENTIRE_DISK_X = '<Entire disk #%1>';
RS_CDROM_IN_X = '<CDROM/DVD in %1>';
RS_DBLCLK_PROMPT_PARTITION = 'Doubleclick partition to display properties';
RS_DBLCLK_PROMPT_DISK = 'Doubleclick to display disk properties';
RS_PARTITION = 'Partition #%1';
RS_PART_ERROR_NO_PARTITION_NO =
'Windows has not allocated this partition a partition number';
RS_PART_ERROR_SYSTEM_PARTITION = 'This is where Windows is installed';
RS_PART_ERROR_PROG_FILES_PARTITION = 'This is where program files are installed';
RS_PART_WARN_BOOTABLE = 'Partition is marked as bootable or required';
procedure TfmeSelectPartition.ckEntireDiskClick(Sender: TObject);
begin
ShowPartitionControl();
NotifyChanged(self);
end;
procedure TfmeSelectPartition.ckShowCDROMClick(Sender: TObject);
begin
PopulateTabs();
TabControl1Change(nil);
NotifyChanged(self);
end;
constructor TfmeSelectPartition.Create(AOwner: TComponent);
begin
inherited;
FRemovableDevices := TStringList.Create();
SDUDiskPartitionsPanel1.OnChanged := SDUDiskPartitionsPanel1Changed;
end;
destructor TfmeSelectPartition.Destroy();
begin
FRemovableDevices.Free();
inherited;
end;
procedure TfmeSelectPartition.Initialize();
procedure ToggleControl(ctrl: TControl);
var
prevValue: Boolean;
begin
prevValue := ctrl.Visible;
ctrl.Visible := False;
ctrl.Visible := True;
ctrl.Visible := prevValue;
end;
begin
actProperties.Enabled := False;
// -- begin [TAB_FIX] --
ToggleControl(SDUDiskPartitionsPanel1);
ToggleControl(pnlNoPartitionDisplay);
ToggleControl(ckShowCDROM);
// -- end [TAB_FIX] --
// Fallback...
SDUDiskPartitionsPanel1.SetCaption(RS_NO_PARTITIONS_FOUND);
SDUDiskPartitionsPanel1.Align := alClient;
pnlNoPartitionDisplay.Align := alClient;
PopulateTabs();
TabControl1Change(nil);
pnlNoPartitionDisplay.Color := GetHighLightColor(COLOR_USABLE);
pnlNoPartitionDisplay.Font.Style := pnlNoPartitionDisplay.Font.Style + [fsBold];
// Yes, this is stupid, but required if frame is on a tab?!!
AllowCDROM := AllowCDROM;
// Sanity...
imgErrorWarning.Width := ilErrorWarning.Width;
imgErrorWarning.Height := ilErrorWarning.Height;
// Set the background color for the error/warning images
ilErrorWarning.BkColor := self.color;
imgErrorWarning.Transparent := True;
// Nudge frame so it sizes itself correctly
self.Resize();
end;
procedure TfmeSelectPartition.PopulateTabs();
var
diskNo: TSDUArrayInteger;
cdromDevices: TStringList;
title: TStringList;
deviceIndicator: DWORD;
i: Integer;
begin
TabControl1.Tabs.Clear();
FRemovableDevices.Clear();
if GetFreeOTFEBase().HDDNumbersList(diskNo) then begin
for i := low(diskNo) to high(diskNo) do begin
deviceIndicator := HIWORD_DISK + DWORD(diskNo[i]);
TabControl1.Tabs.AddObject(SDUParamSubstitute(_('Disk #%1'), [diskNo[i]]),
TObject(deviceIndicator));
end;
end;
if (AllowCDROM and ckShowCDROM.Checked) then begin
cdromDevices := TStringList.Create();
title := TStringList.Create();
try
if GetFreeOTFEBase().CDROMDeviceList(cdromDevices, title) then begin
FRemovableDevices.Assign(cdromDevices);
for i := 0 to (title.Count - 1) do begin
deviceIndicator := HIWORD_CDROM + DWORD(i);
TabControl1.Tabs.AddObject(title[i], TObject(deviceIndicator));
end;
end;
finally
title.Free();
cdromDevices.Free();
end;
end;
if (TabControl1.Tabs.Count > 0) then begin
TabControl1.TabIndex := 0;
end else begin
TabControl1.TabIndex := -1;
end;
end;
procedure TfmeSelectPartition.SDUDiskPartitionsPanel1Changed(Sender: TObject);
begin
NotifyChanged(self);
end;
procedure TfmeSelectPartition.TabControl1Change(Sender: TObject);
var
deviceIndicator: DWORD;
useDevice: Integer;
begin
useDevice := NO_DISK;
if (TabControl1.TabIndex >= 0) then begin
deviceIndicator := DWORD(TabControl1.Tabs.Objects[TabControl1.TabIndex]);
if ((deviceIndicator and HIWORD_DISK) = HIWORD_DISK) then begin
useDevice := (deviceIndicator and $FFFF);
end;
end;
SetPartitionDisplayDisk(useDevice);
ShowPartitionControl();
// We reset this control as if switching from to new disk, we don't want the
// whole disk used, unless the user explicitly selects it
// If CDROM/DVDROM selected, must use whole CD/DVD
ckEntireDisk.Checked := IsCDROMTabSelected();
EnableDisableControls();
NotifyChanged(self);
end;
// Set to NO_PARTITION to indicate control should display no partition
procedure TfmeSelectPartition.SetPartitionDisplayDisk(diskNo: Integer);
var
i: Integer;
blk: TBlock;
begin
// We know what we're doing...
// We trap partitions with partition number zero, and we also paint them
// COLOR_UNUSABLE; see below
SDUDiskPartitionsPanel1.ShowPartitionsWithPNZero := True;
try
SDUDiskPartitionsPanel1.DiskNumber := diskNo;
except
on E: Exception do begin
// Swallow any exception
end;
end;
// Setup the partition colours we want to be used
for i := 0 to (SDUDiskPartitionsPanel1.Count - 1) do begin
blk := SDUDiskPartitionsPanel1.Item[i];
blk.BkColor := COLOR_UNUSABLE;
// Only partitions numbered 1 and above are usable
if (SDUDiskPartitionsPanel1.PartitionInfo[i].PartitionNumber > 0) then begin
blk.BkColor := COLOR_USABLE;
end;
// If synthetic layout, clear block captions
if SDUDiskPartitionsPanel1.SyntheticDriveLayout then begin
blk.Caption := SDUParamSubstitute(RS_PARTITION,
[SDUDiskPartitionsPanel1.PartitionInfo[i].PartitionNumber]);
blk.SubCaption := '';
end;
SDUDiskPartitionsPanel1.Item[i] := blk;
end;
UpdateErrorWarning();
end;
procedure TfmeSelectPartition.ShowPartitionControl();
var
showPartCtrl: Boolean;
begin
showPartCtrl := (
// We have a disk number...
(SDUDiskPartitionsPanel1.DiskNumber > NO_DISK) and
// The partition display is valid...
SDUDiskPartitionsPanel1.DriveLayoutInformationValid and
// We're not using the entire drive
not (ckEntireDisk.Checked));
SDUDiskPartitionsPanel1.Visible := showPartCtrl;
pnlNoPartitionDisplay.Visible := not (showPartCtrl);
actProperties.Visible := True;
if (SDUDiskPartitionsPanel1.DiskNumber > NO_DISK) then begin
if (ckEntireDisk.Checked or not (SDUDiskPartitionsPanel1.DriveLayoutInformationValid)
// Display msg for full disk if no partitions displayed
) then begin
// actProperties.Visible already set to TRUE
end else begin
// Further information on partitions not available if synthetic drive layout
actProperties.Visible := not (SDUDiskPartitionsPanel1.SyntheticDriveLayout);
end;
end;
pnlNoPartitionDisplay.Caption := '';
if (SDUDiskPartitionsPanel1.DiskNumber < 0) then begin
// Sanity check in case there's no tabs
if (TabControl1.TabIndex >= 0) then begin
// CD/DVD drive selected
pnlNoPartitionDisplay.Caption :=
SDUParamSubstitute(RS_CDROM_IN_X, [TabControl1.Tabs[TabControl1.TabIndex]]);
end;
end else begin
if not (SDUDiskPartitionsPanel1.DriveLayoutInformationValid) then begin
pnlNoPartitionDisplay.Caption :=
SDUParamSubstitute(RS_CANT_GET_DISK_LAYOUT, [SDUDiskPartitionsPanel1.DiskNumber]);
end else begin
pnlNoPartitionDisplay.Caption :=
SDUParamSubstitute(RS_ENTIRE_DISK_X, [SDUDiskPartitionsPanel1.DiskNumber]);
end;
end;
end;
function TfmeSelectPartition.GetSelectedDevice(): String;
var
deviceIndicator: DWORD;
useDevice: Integer;
partInfo: TPartitionInformationEx;
partitionNo: Integer;
begin
Result := '';
if (TabControl1.TabIndex >= 0) then begin
deviceIndicator := DWORD(TabControl1.Tabs.Objects[TabControl1.TabIndex]);
useDevice := (deviceIndicator and $FFFF);
if ((deviceIndicator and HIWORD_CDROM) = HIWORD_CDROM) then begin
// Device name can be found in FRemovableDevices
Result := FRemovableDevices[useDevice];
end else
if ((deviceIndicator and HIWORD_DISK) = HIWORD_DISK) then begin
partitionNo := NO_PARTITION;
if SDUDiskPartitionsPanel1.DriveLayoutInformationValid then begin
if ckEntireDisk.Checked then begin
partitionNo := 0;
end else
if (SDUDiskPartitionsPanel1.Selected > NO_PARTITION) then begin
partInfo := SDUDiskPartitionsPanel1.PartitionInfo[SDUDiskPartitionsPanel1.Selected];
// Sanity...
if (partInfo.PartitionNumber <> 0) then begin
partitionNo := partInfo.PartitionNumber;
end;
end;
end;
if (partitionNo > NO_PARTITION) then
Result := SDUDeviceNameForPartition(useDevice, partitionNo);
end;
end;
end;
procedure TfmeSelectPartition.UpdateErrorWarning();
var
msg: String;
showIconWarning: Boolean;
showIconError: Boolean;
useIconidx: Integer;
tmpImg: TIcon;
imgLabelDiff: Integer;
begin
// imgLabelDiff := lblErrorWarning.left - (imgErrorWarning.left + imgErrorWarning.Width);
// imgErrorWarning.left := 0;
// lblErrorWarning.left := 0;
SelectionErrorWarning(msg, showIconWarning, showIconError);
lblErrorWarning.Caption := msg;
useIconidx := ICON_NONE;
if showIconError then
useIconidx := ICON_ERROR
else
if showIconWarning then
useIconidx := ICON_WARNING;
tmpImg := TIcon.Create();
try
ilErrorWarning.GetIcon(useIconidx, tmpImg);
imgErrorWarning.Picture.Assign(tmpImg);
imgErrorWarning.Refresh();
finally
tmpImg.Free();
end;
// lblErrorWarning.left := imgErrorWarning.left + imgErrorWarning.Width + imgLabelDiff;
// CenterErrorWarning();
end;
procedure TfmeSelectPartition.CenterErrorWarning();
var
ctrlArr: TControlArray;
begin
// Center the icon and message
SetLength(ctrlArr, 2);
ctrlArr[0] := imgErrorWarning;
ctrlArr[1] := lblErrorWarning;
SDUCenterControl(ctrlArr, ccHorizontal);
end;
procedure TfmeSelectPartition.NotifyChanged(Sender: TObject);
begin
UpdateErrorWarning();
actProperties.Enabled := (ckEntireDisk.Checked and
(SDUDiskPartitionsPanel1.DiskNumber >= 0)) or (not (ckEntireDisk.Checked) and
// 0 is the entire disk, partitions start at 1
(SDUDiskPartitionsPanel1.Selected >= 0));
if Assigned(FOnChange) then begin
FOnChange(self);
end;
end;
procedure TfmeSelectPartition.SelectionErrorWarning(var msg: String;
var isWarning: Boolean; var isError: Boolean);
var
selectedDriveLetters: String;
bootableFlag: Boolean;
badPartitionNumber: Boolean;
IsGptDisc: Boolean;
// Returns TRUE if the special folder path identified by "clsid" is stored on
// one of the drives listed in "checkDriveLetters". Otherwise returns FALSE
function SystemUsesDrive(clsid: Integer; checkDriveLetters: String): Boolean;
var
path: String;
pathDrive: Char;
begin
Result := False;
path := SDUGetSpecialFolderPath(clsid);
if (length(path) > 1) then begin
pathDrive := path[1];
Result := (Pos(pathDrive, checkDriveLetters) > 0);
end;
end;
procedure UpdateFlagsForPartition(partno: Integer);
var
partInfo: TPartitionInformationEx;
begin
selectedDriveLetters := selectedDriveLetters +
SDUDiskPartitionsPanel1.DriveLetter[partno];
partInfo := SDUDiskPartitionsPanel1.PartitionInfo[partno];
if partInfo.PartitionStyle = PARTITION_STYLE_MBR then
bootableFlag := (bootableFlag or partInfo.mbr.BootIndicator)
else
if partInfo.PartitionStyle = PARTITION_STYLE_GPT then begin
// no 'bootable' fag for gpt - but 'required' flag
bootableFlag :=
bootableFlag or ((partInfo.gpt.Attributes and GPT_ATTRIBUTE_PLATFORM_REQUIRED) > 0);
IsGptDisc := True;
end;
badPartitionNumber := (partInfo.PartitionNumber = 0);
end;
var
i: Integer;
begin
msg := '';
isWarning := False;
isError := False;
IsGptDisc := False;
if (SDUDiskPartitionsPanel1.DiskNumber >= 0) then begin
if not (SDUDiskPartitionsPanel1.DriveLayoutInformationValid) then begin
msg := SDUParamSubstitute(UNABLE_TO_GET_DISK_LAYOUT,
[SDUDiskPartitionsPanel1.DiskNumber]);
isError := True;
end else begin
selectedDriveLetters := '';
bootableFlag := False;
badPartitionNumber := False;
if ckEntireDisk.Checked then begin
for i := 0 to (SDUDiskPartitionsPanel1.Count - 1) do
UpdateFlagsForPartition(i);
badPartitionNumber := False;
// badPartitionNumber never set to TRUE here; entire drive being used
end else begin
if (SDUDiskPartitionsPanel1.Selected >= 0) then
UpdateFlagsForPartition(SDUDiskPartitionsPanel1.Selected);
end;
if badPartitionNumber then begin
// This is *really* fatal - a partition with no partition number?!
// Allowing the user to continue from here could result in the user
// inadvertently overwriting their entire drive, not just a single
// partition!
msg := RS_PART_ERROR_NO_PARTITION_NO;
isError := True;
end else begin
if (SystemUsesDrive(SDU_CSIDL_WINDOWS, selectedDriveLetters) or
SystemUsesDrive(SDU_CSIDL_SYSTEM, selectedDriveLetters)) then begin
msg := RS_PART_ERROR_SYSTEM_PARTITION;
// Note: This is a WARNING and *NOT* an error, as user can have a hidden
// volume stored on this partition
isWarning := True;
end else begin
if SystemUsesDrive(SDU_CSIDL_PROGRAM_FILES, selectedDriveLetters) then begin
msg := RS_PART_ERROR_PROG_FILES_PARTITION;
// Note: This is a WARNING and *NOT* an error, as user can have a hidden
// volume stored on this partition
isWarning := True;
end else begin
if bootableFlag then begin
// Warn user; this could be something like a bootable Linux partition
msg := RS_PART_WARN_BOOTABLE;
isWarning := True;
end;
end;
end;
end;
end;
end;
end;
procedure TfmeSelectPartition.EnableDisableControls();
begin
SDUEnableControl(
ckEntireDisk,
(not (IsCDROMTabSelected()) and SDUDiskPartitionsPanel1.DriveLayoutInformationValid)
);
end;
procedure TfmeSelectPartition.FrameResize(Sender: TObject);
begin
// CenterErrorWarning();
end;
function TfmeSelectPartition.IsCDROMTabSelected(): Boolean;
var
deviceIndicator: DWORD;
begin
Result := False;
if (TabControl1.TabIndex >= 0) then begin
deviceIndicator := DWORD(TabControl1.Tabs.Objects[TabControl1.TabIndex]);
Result := ((deviceIndicator and HIWORD_CDROM) = HIWORD_CDROM);
end;
end;
procedure TfmeSelectPartition.SetAllowCDROM(allow: Boolean);
begin
FAllowCDROM := allow;
ckShowCDROM.Visible := allow;
if not (allow) then
ckShowCDROM.Checked := False;
end;
function TfmeSelectPartition.SelectedSize(): ULONGLONG;
var
partInfo: TPartitionInformationEx;
diskGeometry: TSDUDiskGeometry;
begin
Result := 0;
if (SDUDiskPartitionsPanel1.DiskNumber > NO_DISK) then begin
if ckEntireDisk.Checked then begin
// Return entire disk size
if SDUGetDiskGeometry(SDUDiskPartitionsPanel1.DiskNumber, diskGeometry) then begin
Result := diskGeometry.Cylinders.QuadPart * diskGeometry.TracksPerCylinder *
diskGeometry.SectorsPerTrack * diskGeometry.BytesPerSector;
end;
end else begin
// Return partition size
if (SDUDiskPartitionsPanel1.Selected >= 0) then begin
partInfo := SDUDiskPartitionsPanel1.PartitionInfo[SDUDiskPartitionsPanel1.Selected];
Result := partInfo.PartitionLength;
end;
end;
end;
end;
function TfmeSelectPartition.GetSyntheticDriveLayout(): Boolean;
begin
Result := SDUDiskPartitionsPanel1.SyntheticDriveLayout;
end;
procedure TfmeSelectPartition.actPropertiesExecute(Sender: TObject);
var
dlgPartition: TSDUPartitionPropertiesDialog;
dlgDisk: TSDUDiskPropertiesDialog;
begin
if ckEntireDisk.Checked then begin
if (SDUDiskPartitionsPanel1.DiskNumber >= 0) then begin
dlgDisk := TSDUDiskPropertiesDialog.Create(nil);
try
dlgDisk.fDiskNumber := SDUDiskPartitionsPanel1.DiskNumber;
dlgDisk.ShowModal();
finally
dlgDisk.Free();
end;
end;
end else begin
// 0 is the entire disk, partitions start at 1
if (SDUDiskPartitionsPanel1.Selected >= 0) then begin
dlgPartition := TSDUPartitionPropertiesDialog.Create(nil);
try
dlgPartition.fPartitionInfo :=
SDUDiskPartitionsPanel1.PartitionInfo[SDUDiskPartitionsPanel1.Selected];
dlgPartition.fMountedAsDrive :=
SDUDiskPartitionsPanel1.DriveLetter[SDUDiskPartitionsPanel1.Selected];
dlgPartition.ShowModal();
finally
dlgPartition.Free();
end;
end;
end;
end;
end.
|
unit uPayments;
interface
uses Classes, SysUtils, uTefDial, uTEFDedicado, uSystemConst, uMsgBox,
uTefConsts, uTEFTypes, uTEFDedicadoInterface;
type
TPayment = class;
TPartialPay = class;
TPartialPayEvent = procedure(Payment: TPayment; Lista: TList; var Sucess: Boolean) of object;
TPayments = class(TComponent)
private
FItems: TList;
FTEFDial: TTEFDial;
FCOO: String;
FInvoiceTotal: Currency;
FCashTotal: Currency;
FCashReceivedTotal: Currency;
FChangeTotal: Currency;
FBalanceTotal: Currency;
FOnPartialPay: TPartialPayEvent;
FIsRefund: Boolean;
FTEFDedicado: TTEFDedicado;
FTEFType: Integer;
FTEFDedicadoInterface: TTEFDedicadoInterface;
function ConfirmLastTEFs: Boolean;
function GetItems(Index: Integer): TPayment;
procedure SetItems(Index: Integer; const Value: TPayment);
procedure InitValues;
procedure UpdateValues;
procedure SetInvoiceTotal(const Value: Currency);
function GetCount: Integer;
procedure RemovePayment(Index: Integer);
function ParcelaDefault(AAutorization: String; AValue: Currency): TPartialPay;
function CountPaymentsByType(iTipo: Integer): Integer;
function HaveTEF: Boolean;
function TefDedicadoRestricoes(Payment: TPayment): String;
public
property COO: String read FCOO write FCOO;
property Count: Integer read GetCount;
property Items[Index: Integer]: TPayment read GetItems write SetItems;
property InvoiceTotal: Currency read FInvoiceTotal write SetInvoiceTotal;
property CashTotal: Currency read FCashTotal;
property CashReceivedTotal: Currency read FCashReceivedTotal write FCashReceivedTotal;
property ChangeTotal: Currency read FChangeTotal;
property BalanceTotal: Currency read FBalanceTotal;
property IsRefund: Boolean read FIsRefund write FIsRefund;
constructor Create(AOwner: TComponent);override;
destructor Destroy;override;
function Add(const Value: TPayment): Integer;
function AddPayment(AIDMeioPag, ATipo: Integer; ACodFiscal,
ADescFiscal: String; AAmount: Currency;
ATEFCallInfo : TTEFCallInfo;
APaymentPlace: Integer = 0) : Boolean;
procedure Clear;
procedure Delete(Index: Integer);
function GetPaymentsAmount(ATipo: Integer = -1): Currency;
function LastPayment: TPayment;
function Reset: Boolean;
published
property TEFDial: TTEFDial read FTEFDial write FTEFDial;
property TEFDedicado: TTEFDedicado read FTEFDedicado write FTEFDedicado;
property TEFDedicadoInterface: TTEFDedicadoInterface read FTEFDedicadoInterface write FTEFDedicadoInterface;
property TEFType: Integer read FTEFType write FTEFType;
property OnPartialPay: TPartialPayEvent read FOnPartialPay write FOnPartialPay;
end;
TTEFInfo = class
private
FNSU: String;
FAutorization: String;
FNomeRede: String;
FValorTotal: Currency;
FDataTransacao: String;
FHoraTransacao: String;
FConfirmed: Boolean;
FIDPreSale: Integer;
public
property Autorization: String read FAutorization write FAutorization;
property NSU: String read FNSU write FNSU;
property NomeRede: String read FNomeRede write FNomeRede;
property ValorTotal: Currency read FValorTotal write FValorTotal;
property DataTransacao: String read FDataTransacao write FDataTransacao;
property HoraTransacao: String read FHoraTransacao write FHoraTransacao;
property Confirmed: Boolean read FConfirmed write FConfirmed;
property IDPreSale: Integer read FIDPreSale write FIDPreSale;
end;
TPayment = class
private
FIDMeioPag: Integer;
FAmount: Currency;
FTipo: Integer;
FIDLancamento: Integer;
FTEFInfo: TTEFInfo;
FCodFiscal: String;
FDescFiscal: String;
FPartialPay: Boolean;
FPaymentPlace: Integer;
FItems: TList;
FTEFCartaoMagnetico : Boolean;
FTEFTipoParcelamento : Integer;
FTEFPreDatada : TDateTime;
FTEFPreDatadaComGarantia : Boolean;
FTEFUsaCDC : Boolean;
FTEFConsultaPreAuto : Boolean;
FTEFBandeira: Integer;
FTipoTEF: Integer;
FIDPreSale: Integer;
function GetItems(Index: Integer): TPartialPay;
procedure SetItems(Index: Integer; const Value: TPartialPay);
function GetCount: Integer;
procedure SetIDPreSale(const Value: Integer);
public
constructor Create;
destructor Destroy; override;
property IDMeioPag: Integer read FIDMeioPag write FIDMeioPag;
property Amount: Currency read FAmount write FAmount;
property Tipo: Integer read FTipo write FTipo;
property IDLancamento: Integer read FIDLancamento write FIDLancamento;
property TEFInfo: TTEFInfo read FTEFInfo write FTEFInfo;
property CodFiscal: String read FCodFiscal write FCodFiscal;
property DescFiscal: String read FDescFiscal write FDescFiscal;
property PaymentPlace: Integer read FPaymentPlace write FPaymentPlace default -1;
property PartialPay: Boolean read FPartialPay write FPartialPay;
property Items[Index: Integer]: TPartialPay read GetItems write SetItems;
property TEFCartaoMagnetico : Boolean read FTEFCartaoMagnetico write FTEFCartaoMagnetico;
property TEFTipoParcelamento : Integer read FTEFTipoParcelamento write FTEFTipoParcelamento;
property TEFPreDatada : TDateTime read FTEFPreDatada write FTEFPreDatada;
property TEFPreDatadaComGarantia : Boolean read FTEFPreDatadaComGarantia write FTEFPreDatadaComGarantia;
property TEFUsaCDC : Boolean read FTEFUsaCDC write FTEFUsaCDC;
property TEFConsultaPreAuto : Boolean read FTEFConsultaPreAuto write FTEFConsultaPreAuto;
property TEFBandeira : Integer read FTEFBandeira write FTEFBandeira;
property TipoTEF : Integer read FTipoTEF write FTipoTEF;
property Count: Integer read GetCount;
property IDPreSale: Integer read FIDPreSale write SetIDPreSale;
function Add(const Value: TPartialPay): Integer;
end;
TPartialPay = class
private
FValue: Currency;
FIDBanco: Integer;
FNumeroDoc: String;
FTelefone: String;
FParcela: String;
FOBS: String;
FAutorization: String;
FNomeCliente: String;
FDocCliente: String;
FBanco: String;
FExpireDate: TDateTime;
public
property Autorization: String read FAutorization write FAutorization;
property NomeCliente: String read FNomeCliente write FNomeCliente;
property Telefone: String read FTelefone write FTelefone;
property DocCliente: String read FDocCliente write FDocCliente;
property IDBanco: Integer read FIDBanco write FIDBanco;
property NumeroDoc: String read FNumeroDoc write FNumeroDoc;
property OBS: String read FOBS write FOBS;
property ExpireDate: TDateTime read FExpireDate write FExpireDate;
property Parcela: String read FParcela write FParcela;
property Value: Currency read FValue write FValue;
property Banco: String read FBanco write FBanco;
end;
procedure Register;
implementation
{ TPayments }
function TPayments.Add(const Value: TPayment): Integer;
begin
Result := FItems.Add(Value);
UpdateValues;
end;
function TPayments.ConfirmLastTEFs: Boolean;
var
I : Integer;
ATEFInfo: TTEFInfo;
begin
Result := True;
for I := 0 to FItems.Count - 1 do
begin
ATEFInfo := GetItems(I).FTEFInfo;
if ATEFInfo <> nil then
if not ATEFInfo.Confirmed then
begin
case FTEFType of
TEF_NONE:;
TEF_DIAL:
begin
FTEFDial.CupomVinculado := FCOO;
FTEFDial.NSU := ATEFInfo.NSU;
FTEFDial.NomeRede := ATEFInfo.NomeRede;
FTEFDial.ValorTotal := ATEFInfo.ValorTotal;
ATEFInfo.Confirmed := FTEFDial.ConfirmacaoSimples;
Result := Result and ATEFInfo.Confirmed;
end;
TEF_DEDICADO:
begin
ATEFInfo.Confirmed := True;
end;
end;
if not Result then
Break;
end;
end;
end;
constructor TPayments.Create(AOwner: TComponent);
begin
if not (csDesigning in ComponentState) then
FItems := TList.Create;
//FCanDoTEF := True;
InitValues;
inherited Create(AOwner);
end;
procedure TPayments.Delete(Index: Integer);
begin
RemovePayment(Index);
FItems.Delete(Index);
UpdateValues;
end;
procedure TPayments.RemovePayment(Index: Integer);
var
TEFInfo: TTEFInfo;
Payment: TPayment;
begin
if FItems[Index] = nil then
Exit;
if TPayment(FItems[Index]).TEFInfo <> nil then
begin
TEFInfo := TPayment(FItems[Index]).TEFInfo;
FreeAndNil(TEFInfo);
end;
Payment := TPayment(FItems[Index]);
FreeAndNil(Payment);
end;
destructor TPayments.Destroy;
begin
if not (csDesigning in ComponentState) then
begin
while FItems.Count > 0 do
RemovePayment(0);
FItems.Free;
end;
inherited Destroy;
end;
function TPayments.GetItems(Index: Integer): TPayment;
begin
Result := FItems[Index];
end;
function TPayments.GetPaymentsAmount(ATipo: Integer): Currency;
var
I : Integer;
begin
Result := 0;
for I := 0 to FItems.Count - 1 do
with GetItems(I) do
if (ATipo = -1) or (ATipo = Tipo) then
Result := Result + Amount;
end;
procedure TPayments.InitValues;
begin
FInvoiceTotal := 0;
FCashTotal := 0;
FCashReceivedTotal := 0;
FChangeTotal := 0;
FBalanceTotal := 0;
end;
procedure TPayments.UpdateValues;
var
Pagamentos: Currency;
begin
Pagamentos := GetPaymentsAmount;
FBalanceTotal := FInvoiceTotal - Pagamentos;
FCashTotal := GetPaymentsAmount(1{PAYMENT_TYPE_CASH});
if FCashReceivedTotal < FCashTotal then
FCashReceivedTotal := FCashTotal;
{
if (FInvoiceTotal - Pagamentos) < 0 then
FChangeTotal := ABS((FInvoiceTotal - Pagamentos))
else
FChangeTotal := 0;}
end;
procedure TPayments.SetItems(Index: Integer; const Value: TPayment);
begin
FItems[Index] := Value;
UpdateValues;
end;
function TPayments.Reset: Boolean;
begin
Result := True;
try
if HaveTEF then
repeat
Result := TEFDial.ResolvePendencias;
until Result;
finally
Clear;
InitValues;
end;
end;
function TPayments.HaveTEF: Boolean;
var
I: Integer;
begin
Result := False;
for I := 0 to FItems.Count - 1 do
begin
if TPayment(FItems[I]).FTEFInfo <> nil then
begin
Result := True;
Break;
end;
end;
end;
procedure TPayments.Clear;
begin
while FItems.Count > 0 do
Delete(0);
end;
procedure TPayments.SetInvoiceTotal(const Value: Currency);
begin
FInvoiceTotal := Value;
UpdateValues;
end;
function TPayments.LastPayment: TPayment;
begin
Result := nil;
if FItems.Count > 0 then
Result := TPayment(FItems[FItems.Count - 1]);
end;
function TPayments.GetCount: Integer;
begin
Result := FItems.Count;
end;
function TPayments.AddPayment(AIDMeioPag, ATipo: Integer; ACodFiscal,
ADescFiscal: String; AAmount: Currency; ATEFCallInfo : TTEFCallInfo;
APaymentPlace: Integer): Boolean;
var
Payment: TPayment;
ATEFInfo: TTEFInfo;
CanAdd: Boolean;
Valor, Troco: Currency;
PartialList: TList;
FezParcial: Boolean;
AAutorization: String;
I : Integer;
NumeroCartoes: Integer;
VinculadoInfo: TVinculadoInfo;
APartialPay : Boolean;
begin
Troco := 0;
AAutorization := '000';
Result := False;
CanAdd := True;
ATEFInfo := nil;
Valor := AAmount;
NumeroCartoes := CountPaymentsByType(PAYMENT_TYPE_CARD) + CountPaymentsByType(PAYMENT_TYPE_DEBIT);
// Trata o Troco
if ((Valor > FBalanceTotal) and not IsRefund) or
((Valor <> FBalanceTotal) and IsRefund) then
begin
Troco := Valor - FBalanceTotal;
Valor := FBalanceTotal;
end;
// Criacao do Pagamento
Payment := TPayment.Create;
with Payment do
begin
IDMeioPag := AIDMeioPag;
Amount := Valor;
Tipo := ATipo;
CodFiscal := ACodFiscal;
DescFiscal := ADescFiscal;
PaymentPlace := APaymentPlace;
if ATEFCallInfo <> nil then
begin
PartialPay := ATEFCallInfo.PostDate;
TEFCartaoMagnetico := ATEFCallInfo.IsMagnetico;
TEFUsaCDC := ATEFCallInfo.UsaCDC;
TEFConsultaPreAuto := ATEFCallInfo.UsaPreAutorizacao;
TEFBandeira := ATEFCallInfo.Bandeira;
TipoTEF := ATEFCallInfo.TipoTEF;
//FTEFType := ATEFCallInfo.TipoTEF;
end
else
begin
PartialPay := False;
(*
HOMOLOGACAO - Setar para FTEFType zero caso não seja TEF
*)
//FTEFType := TEF_NONE;
end;
end;
APartialPay := Payment.PartialPay;
// Lista de parcelas para o evento
PartialList := TList.Create;
FezParcial := False;
try
// Trata TEF
if (FTEFType <> TEF_NONE) and (ATEFCallInfo <> nil) then
begin
(*
HOMOLOGAÇÂO DO TEF - DISCADO - 4 CARTÕES
*)
if (ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT]) and (NumeroCartoes > 2) and (Valor < FBalanceTotal) then
begin
MsgBox('O valor do pagamento do segundo cartão deve completar o valor da nota..', vbCritical + vbOKOnly);
if Payment <> nil then
FreeAndNil(Payment);
Exit;
end;
if (not (ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT])) and (NumeroCartoes > 0) and (FTEFType = TEF_DIAL) then
begin
MsgBox('As próximas formas de pagamento para esta venda deverão ser em CARTÃO DE CRÉDITO OU DÉBITO.', vbCritical+vbOKOnly);
if Payment <> nil then
FreeAndNil(Payment);
Exit;
end;
(*TEF Dedicado
Temos que preencher os dados antes de enviar para o TEF Dedicado. No caso
do TEF Discado, essa opção e inversa ou seja o resultado vem do aplicativo do TEF
*)
if APartialPay then
if ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT, PAYMENT_TYPE_CHECK]) and ((FTEFType = TEF_DEDICADO))) then
if Assigned(FOnPartialPay) then
begin
// Chamada do Evento se for TEF Dedicado
FOnPartialPay(Payment, PartialList, FezParcial);
if not FezParcial then
Exit;
end;
if ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT]) AND ((FTEFType <> TEF_NONE) )) then
//if ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT, PAYMENT_TYPE_CHECK]) AND ((FTEFType <> TEF_NONE) )) then
//if ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT]) or ((FTEFType = TEF_DEDICADO) )) then
begin
ConfirmLastTEFs;
case FTEFType of
TEF_DIAL:
begin
FTEFDial.CupomVinculado := Trim(FCOO);
FTEFDial.FormaPagamento := ADescFiscal;
FTEFDial.ValorTotal := AAmount;
FTEFDial.IDMeioPag := AIDMeioPag;
FTEFDial.TEFDIALType := Payment.TipoTEF;
if ATipo = PAYMENT_TYPE_CHECK then
CanAdd := FTEFDial.VendaCheque
else
CanAdd := FTEFDial.VendaCartao;
end;
TEF_DEDICADO:
begin
// Aqui entra a merda do código do tef dedicado
VinculadoInfo := TVinculadoInfo.Create;
VinculadoInfo.CupomVinculado := Trim(FCOO);
VinculadoInfo.FormaPagamento := ADescFiscal;
VinculadoInfo.ValorAprovado := AAmount;
VinculadoInfo.IDMeioPag := AIDMeioPag;
VinculadoInfo.NumeroParcelas := PartialList.Count;
VinculadoInfo.PreDatado := Payment.TEFPreDatada;
VinculadoInfo.PreDatadoComGarantia := Payment.TEFPreDatadaComGarantia;
CanAdd := FTEFDedicado.FazTransacao(FUNCAO_PAGAMENTO,
AAmount,
Trim(FCOO),
Now,
'',
TefDedicadoRestricoes(Payment),
'',
VinculadoInfo,
FTEFDedicadoInterface) = 0;
end;
end;
if CanAdd then
case FTEFType of
TEF_DIAL:
begin
Valor := FTEFDial.ValorAprovado;
ATEFInfo := TTEFInfo.Create;
with ATEFInfo do
begin
COO := FCOO;
NSU := FTEFDial.NSU;
Autorization := FTEFDial.Autorizacao;
NomeRede := FTEFDial.NomeRede;
ValorTotal := FTEFDial.ValorTotal;
DataTransacao := FTEFDial.DataTransacao;
HoraTransacao := FTEFDial.HoraTransacao;
Confirmed := False;
AAutorization := Autorization;
end;
end;
TEF_DEDICADO:
begin
ATEFInfo := TTEFInfo.Create;
with ATEFInfo do
begin
COO := FCOO;
Confirmed := False;
end;
end;
end;
end;
end;
if CanAdd then
begin
Payment.TEFInfo := ATEFInfo;
// Vai Parcelar
if APartialPay then
begin
// Evento de Parcelamento
if Assigned(FOnPartialPay) then
begin
try
// Chamada do Evento se for TEF Discado ou none
if ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT, PAYMENT_TYPE_CHECK, PAYMENT_TYPE_STOREACCOUNT]) and (FTEFType <> TEF_DEDICADO)) then
FOnPartialPay(Payment, PartialList, FezParcial);
// Parcelou ?
if (FezParcial) and (PartialList.Count <> 0) then
begin
// Sim, adiciona cada parcela
for I := 0 to PartialList.Count - 1 do
Payment.Add(TPartialPay(PartialList[I]))
end
// Nao
else
begin
// Fez TEF ?
if (FTEFType <> TEF_NONE) and ((ATipo in [PAYMENT_TYPE_CARD, PAYMENT_TYPE_DEBIT, PAYMENT_TYPE_CHECK, PAYMENT_TYPE_STOREACCOUNT]) or ((FTEFType = TEF_DEDICADO) )) then
// Sim, Adiciona uma parcela
Payment.Add(ParcelaDefault(AAutorization, Valor))
else
// Nao. Rejeita pagamento
FreeAndNil(Payment);
end;
finally
end;
end;
end
else
Payment.Add(ParcelaDefault(AAutorization, Valor));
Result := Payment <> nil;
if Result then
begin
FChangeTotal := FChangeTotal + Troco;
Add(Payment);
end;
end;
finally
FreeAndNil(PartialList);
end;
end;
function TPayments.ParcelaDefault(AAutorization: String; AValue: Currency): TPartialPay;
begin
Result := TPartialPay.Create;
with Result do
begin
ExpireDate := NOW;
Autorization := AAutorization;
Value := AValue;
Parcela := '1/1';
end;
end;
function TPayments.CountPaymentsByType(iTipo: Integer): Integer;
var
I : Integer;
begin
Result := 0;
for I := 0 to FItems.Count - 1 do
if TPayment(FItems[I]).Tipo = iTipo then
Inc(result);
end;
function TPayments.TefDedicadoRestricoes(Payment: TPayment): String;
var
RestrictionSet, OutOfRestrictionSet: set of Byte;
i: Byte;
begin
OutOfRestrictionSet := [];
if Payment.TEFBandeira = TEF_BANDEIRA_FININVEST then
begin
OutOfRestrictionSet := [TEF_BANDEIRA_FININVEST];
end
else
case Payment.Tipo of
PAYMENT_TYPE_CARD: begin
if Payment.PartialPay then
begin
if Payment.TEFTipoParcelamento = TEF_PARCELAMENTO_LOJA then
OutOfRestrictionSet := [25,27]
else if Payment.TEFTipoParcelamento = TEF_PARCELAMENTO_ADM then
OutOfRestrictionSet := [25,28];
end
else
OutOfRestrictionSet := [25,26];
if Payment.TEFCartaoMagnetico then
OutOfRestrictionSet := OutOfRestrictionSet + [30]
else
OutOfRestrictionSet := OutOfRestrictionSet + [29];
end;
PAYMENT_TYPE_DEBIT: begin
if Payment.PartialPay then
begin
if Payment.TEFTipoParcelamento = TEF_PARCELAMENTO_LOJA then
OutOfRestrictionSet := [15,17]
else if Payment.TEFTipoParcelamento = TEF_PARCELAMENTO_ADM then
OutOfRestrictionSet := [15,18];
end
else
begin
OutOfRestrictionSet := [15];
if not Payment.TEFUsaCDC then
OutOfRestrictionSet := OutOfRestrictionSet + [16] //A Vista
else
OutOfRestrictionSet := OutOfRestrictionSet + [19]; //Opcao de CDC
end;
if Payment.TEFCartaoMagnetico then
OutOfRestrictionSet := OutOfRestrictionSet + [43]
else
OutOfRestrictionSet := OutOfRestrictionSet + [42];
end;
PAYMENT_TYPE_CHECK: OutOfRestrictionSet := [10..14];
end;
if Payment.TEFConsultaPreAuto then
OutOfRestrictionSet := OutOfRestrictionSet + [31];
RestrictionSet := TEF_PAYMENTS - OutOfRestrictionSet;
for I := 0 to High(Byte) do
begin
if I in RestrictionSet then
Result := Result + IntToStr(I) + ';';
end;
//Result := '[' + Result + '];';
Result := '';
end;
{ TPayment }
function TPayment.Add(const Value: TPartialPay): Integer;
begin
Result := FItems.Add(Value);
end;
constructor TPayment.Create;
begin
inherited Create;
FItems := TList.Create;
FTEFInfo := nil;
FPaymentPlace := -1;
FTEFTipoParcelamento := TEF_PARCELAMENTO_LOJA;
FTEFCartaoMagnetico := True;
end;
destructor TPayment.Destroy;
begin
FreeAndNil(FItems);
inherited Destroy;
end;
procedure Register;
begin
RegisterComponents('NewPower', [TPayments]);
end;
function TPayment.GetCount: Integer;
begin
Result := FItems.Count;
end;
function TPayment.GetItems(Index: Integer): TPartialPay;
begin
Result := FItems[Index];
end;
procedure TPayment.SetIDPreSale(const Value: Integer);
begin
FIDPreSale := Value;
if Assigned(FTEFInfo) then
FTEFInfo.FIDPreSale := Value;
end;
procedure TPayment.SetItems(Index: Integer; const Value: TPartialPay);
begin
FItems[Index] := Value;
end;
end.
|
unit uSystemConst;
interface
uses Messages;
const
//SOFTVAR CONST
PDV_MD5 = '00fe96bc61c96a87414ab6874098b584';
//Main Retail Const
STORE_MARK = '#STORE_ACCESS_LIST#';
TEMP_TABLE = '*TempTable*';
REGISTRY_PATH = 'SOFTWARE\Applenet\MainRetail';
REGISTRY_POS_PATH = 'SOFTWARE\Applenet\POS';
EMPRESA_DEFAULT = 0;
MEDIA_TYPE_TOURGROUP = 1;
MEDIA_TYPE_GUIDE = 2;
XPRESS_SALE_RETAIL = 0;
XPRESS_SALE_SUPERMARKET = 1;
TAX_MODE_MANAGER = 1;
TAX_MODE_SALEPERSON = 2;
TAX_MODE_AUTO = 3;
TYPE_VENDORID = 1;
TYPE_GUIDEID = 2;
TYPE_AGENCYID = 3;
PARAM_START_LAYAWAY = 'start_layaway';
PARAM_START_INVENT_ADJST = 'start_inv_adjst';
REQ_TYPE_SALESPERSON = 'P';
REQ_TYPE_COMPUTER = 'C';
REQ_TYPE_BUYER = 'B';
REQ_STATUS_ONREQUEST = 'R';
REQ_STATUS_ONORDER = 'O';
REQ_STATUS_ONARRIVED = 'A';
FISCAL_ITEM_COD = '#COD#=';
FISCAL_ITEM_DESCRIP = '#DESC#=';
FISCAL_ITEM_ALIQ = '#ALIQ#=';
FISCAL_ITEM_TIPO_QTY = '#TQTY#=';
FISCAL_ITEM_QTY = '#QTY#=';
FISCAL_ITEM_CASA_DEC = '#CDEC#=';
FISCAL_ITEM_VALOR_UNIT = '#VUNIT#=';
FISCAL_ITEM_TIPO_DESC = '#TDESC#=';
FISCAL_ITEM_VALOR_DESC = '#VDESC#=';
FISCAL_ITEM_VALOR_TOTAL = '#VTOT#=';
FISCAL_ITEM_POSITION = '#IPOS#=';
FISCAL_ITEM_PONTO_DEC = '#PDEC#=';
FISCAL_ITEM_TP_ITEM = '#TPIT#=';
FISCAL_FECHA_NOTA_ACRES_DESC = '#ACDESC#=';
FISCAL_FECHA_NOTA_TIPO_ACRES_DESC = '#TACDESC#=';
FISCAL_FECHA_NOTA_VALOR_ACRES_DESC= '#VACDESC#=';
FISCAL_FECHA_NOTA_VALOR_DESCO = '#VDESCO#=';
FISCAL_FECHA_NOTA_VALOR_PAGO = '#VPGTO#=';
FISCAL_FECHA_NOTA_TIPO_PAGAMENTO = '#TPAG#=';
FISCAL_FECHA_NOTA_MSG = '#FMSG#=';
FISCAL_FECHA_NOTA_IDX_PAGAMENTO = '#IDPGTO#=';
SQL_STATUS_NO_CONNECTED = 'Not connected';
SQL_STATUS_CONNECTED = 'Connected';
SQL_STATUS_ERROR = 'Connection error';
HIST_RETAIL = 1;
HIST_COST = 2;
HIST_MARKUP = 3;
HIST_GROSS = 4;
HIST_PROFIT = 5;
PESSOA_TIPO_CLIENTE = 1;
PESSOA_TIPO_FORNECEDOR = 2;
PESSOA_TIPO_COMISSIONADO = 3;
PESSOA_TIPO_VENDEDOR = 4;
PESSOA_TIPO_GUIA = 5;
PESSOA_TIPO_AGENCIA = 6;
PESSOA_TIPO_FABRICANTE = 7;
SALE_PRESALE = 0;
SALE_CASHREG = 1;
SALE_INVOICE = 2;
SALE_UNLOCK_PRESALE = 3;
SALE_SPLIT_PRESALE = 4;
SALE_MOVE_PRESALE = 5;
USER_TYPE_ADMINISTRATOR = 1;
USER_TYPE_MANAGER = 2;
USER_TYPE_ASSIST_MANAGER = 6; // ** Ivanil
USER_TYPE_CASHIER = 3; // ** Ivanil
USER_TYPE_CASHIER_PO = 5; // ** Ivanil
REC_INVOICE = 1;
REC_SLIP = 2;
PAY_TYPE_CASH = 1;
PAY_TYPE_VISA = 2;
PAY_TYPE_AMERICAN = 3;
PAY_TYPE_MASTER = 4;
PAY_TYPE_CHECK = 5;
PAYMENT_TYPE_CASH = 1;
PAYMENT_TYPE_CARD = 2;
PAYMENT_TYPE_OTHER = 3;
PAYMENT_TYPE_CHECK = 4;
PAYMENT_TYPE_CREDIT = 5;
PAYMENT_TYPE_GIFTCARD = 6;
PAYMENT_TYPE_DEBIT = 7;
PAYMENT_TYPE_BONUSBUCK = 8;
PAYMENT_TYPE_STOREACCOUNT = 9;
DELIVER_TYPE_ONHAND = 1;
LANC_TYPE_SALE = 1;
LANC_TYPE_BUY = 2;
ST_CASHREG_OPEN = 1;
ST_CASHREG_CLOSE = 2;
ST_CASHREG_CONF = 3;
TIPODOC_SALE = 1;
TIPODOC_BUY = 2;
TIPODOC_TRANSF = 3;
TIPODOC_PEDSALE = 4;
MOV_TYPE_SALE = 1;
MOV_TYPE_BUY = 2;
MOV_TYPE_ADJUST = 3;
PARAM_TAX = 1;
PARAM_SALEONNEGATIVE = 2;
PARAM_FASTSALE = 3;
PARAM_REFRESHONINSERT = 4;
PARAM_REFRESHINTERVAL = 5;
PARAM_REFRESHBROWSE = 6;
PARAM_MAXROWS = 7;
PARAM_MODIFYCOST = 8;
PARAM_CASHREGRESTANT = 9;
PARAM_LICENSE = 10;
PARAM_MAXCASHALLOWED = 11;
PARAM_CLOSECASHRANDOM = 12;
PARAM_MAXQTYCOMPUTERREQ = 13;
PARAM_MINSALECOMPUTERREQ = 14;
PARAM_INCLUDEPREPURCHASE = 15;
PARAM_ANYONEMANAGECASHREG = 31;
PARAM_SHOWTABNOCUSTUMERREGISTER = 32;
PARAM_SHOWTABCUSTUMERREGISTER = 33;
PARAM_SHOWTABTOURGROUP = 34;
PARAM_COMMISSIONBONUS = 35;
PARAM_SHOWNAME_NOREGISTERCUSTUMER = 36;
PARAM_MAX_WORKING_HOUR_PER_DAY = 37;
PARAM_SHOW_PRICE_PRE_RECEIVE = 38;
PARAM_SHOW_MENU_ICONS = 39;
PARAM_SHOW_LAYAWAY_CR_HIST = 41;
PARAM_SHOW_LAYAWAY_INVOICE_HIST = 40;
PARAM_PRINT_DEPOSIT = 42;
PARAM_SHOWTABLAYAWAY = 43;
PARAM_CHECKSERIALNUMBER = 44;
PARAM_MARKUPOVERCOST = 45;
PARAM_PRINT_ON_OPENCASHREG = 46;
PARAM_NUM_ITEM_TO_PRINT = 47;
PARAM_DISPLAY_PRE_DATADO = 48;
PARAM_CONFIRM_DELIVERY_ON_SALE = 49;
PARAM_DISPLAY_PAYMENT_PLACE = 50;
PARAM_ENTER_LAYAWAY_FULL_AMOUNT = 51;
PARAM_INVOICE_SHOW_TAB_OTHER_COSTS = 52;
PARAM_INVOICE_SHOW_TAB_PAYMENTS = 53;
PARAM_INVOICE_SHOW_TAB_AGENTS = 54;
PARAM_INVOICE_SHOW_TAB_DELIVERY = 55;
PARAM_INVOICE_SHOW_TAB_DEPOSIT_DATE = 56;
PARAM_INVOICE_SHOW_TAB_DISCOUNT = 57;
PARAM_MAX_NUMBER_PAYMENTS = 58;
PARAM_CONSULTA_SERASA = 59;
PARAM_CONSULTA_ZIPCODE = 60;
PARAM_MAX_NUMBER_DAYS_PAYING_NOW = 61;
PARAM_CONFIRM_DELIVERY_AFTER_FINISH_SALE = 62;
PARAM_SALE_SCREEN_TYPE = 63;
PARAM_TAX_EXEMPT_ON_SALE = 64;
PARAM_DISPLAY_QTY_FLOATING = 65;
PARAM_TAX_IN_COSTPRICE = 66;
PARAM_PETSHOP_OPTIONS = 67;
PARAM_USE_ESTIMATED_COST = 68;
PARAM_MARK_DELIVERY_HOUR = 69;
PARAM_DISPLAY_CUSTOMER_INFO = 70;
PARAM_VERIFY_PGTO_BEFORE_DELIVERY = 71;
PARAM_TAX_COST_USE_MARKUP_ON_COST = 72;
PARAM_PUPPY_TRACKER_INTEGRATION = 73;
PARAM_ASK_PASSWORD_BEFORE_OPEN_SOFTWARE = 74;
PARAM_CALC_MARGIN = 75;
PARAM_CALC_ROUNDING = 76;
PARAM_REMOVE_BARCODE_DIGIT = 77;
PARAM_SEARCH_MODEL_AFTER_BARCODE = 78;
PARAM_AUTO_GENERATE_MODEL = 79;
PARAM_APPLY_PROMO_ON_SALE = 80;
PARAM_PROMPT_COMMISSIONER_ON_SALE = 81;
PARAM_SALECODE_ON_CREATE_SALE = 82;
PARAM_TREAT_HOLD_AS_INVOICE = 83;
PARAM_SEND_ITEM_FOR_TRASH = 84;
PARAM_USE_FRACTIONARY_QTY = 85;
PARAM_GIFT_EXP_DATE = 86;
PARAM_PROGRESSIVE_QTY_DISCOUNT = 87;
PARAM_USE_CATALOG = 88;
PARAM_ASK_SALEPRICE = 89;
PARAM_MIN_BARCODE_LENGTH = 90;
PARAM_PETCENTER_INTEGRATION = 91;
PARAM_APPLY_BONUS_ON_SALE = 92;
PARAM_CREATE_SUBCATEGORY_ON_IMPORT = 93;
PARAM_LIMIT_LAYAWAY_ON_MONTH = 94;
PARAM_VALIDATE_CASE_QTY_ON_HOLD = 95;
PARAM_APPLY_INV_DISCOUNT_ON_ITEMS = 96;
PARAM_USE_PRICE = 97;
PARAM_USE_IDENT_NUMBER_SERIAL = 98;
PO_ONTIME = 0;
PO_ONTIME_ARRIVED = 1;
PO_ONDELAY = 2;
PO_ONDELAY_ARRIVED = 3;
PO_ALL = 4;
PO_ALL_ARRIVED = 5;
CASHREG_OPEN = 0;
CASHREG_CLOSE = 1;
CASHREG_ERROR = 2;
TRIAL_LIMIT = 6000;
//Update Pack 3
SQL_REG_PATH = 'Software\Microsoft\MSSQLServer\MSSQLServer\CurrentVersion';
SQL_GO = 'GO';
//Main Retail ID fields
MR_INVENTORY_MOV_ID = 'InventoryMov.IDInventoryMov';
MR_GROUP_COST_ID = 'GroupCost.IDCost';
MR_TIME_CONTROL_ID = 'TMC_TimeControl.IDTime';
MR_MODEL_ID = 'Model.IDModel';
MR_PESSOA_ID = 'Pessoa.IDPessoa';
MR_SYSTEMUSER_ID = 'SystemUser.IDUser';
MR_STORE_ID = 'Store.IDStore';
MR_TAX_CATEG_ID = 'TaxCategory.IDTaxCategory';
MR_CASH_REG_ID = 'CashRegister.IDCashRegister';
MR_CATEGORY_ID = 'TabGroup.IDGroup';
MR_REQUEST_ID = 'Request.IDRequest';
MR_PRESALE_ID = 'Invoice.IDPreSale';
MR_APPHISTORY_ID = 'Sis_AppHistory.IDHistory';
MR_PURCHASE_ITEM_ID = 'Pur_PurchaseItem.IDPurchaseItem';
MR_PURCHASE_ITEM_SN_ID = 'Pur_PurchaseItemSerial.IDPurchaseItemSerial';
APPLENET_REGISTRY_KEY = 'SOFTWARE\AppleNet';
//Replication Server
SYSTEM_STANDALONE_TYPE = 'STAND_ALONE';
SYSTEM_SERVER_TYPE = 'SERVER';
SYSTEM_CLI_MASTER_TYPE = 'CLI_MASTER';
SYSTEM_CLI_STATION_TYPE = 'CLI_STATION';
//Detail
TICKET_MODEL = '[MODEL]';
TICKET_DESCRIPTION = '[DESCRIPTION]';
TICKET_SP = '[SP]';
TICKET_SPN = '[SP_#]';
TICKET_BARCODE = '[BARCODE]';
TICKET_SERIALNUMBER = '[SN]';
TICKET_QTY = '[QTY]';
TICKET_UNIT_PRICE = '[UNITPRICE]';
TICKET_UNIT_TOTAL = '[UNIT_TOTAL]';
TICKET_ALIGN_RIGHT = '{> <}';
//Header
TICKET_DATE = '[DATE]';
TICKET_TIME = '[TIME]';
TICKET_CUSTOMER = '[CUSTOMER]';
TICKET_MEDIA = '[MEDIA]';
TICKET_CASHIER = '[CASHIER]';
TICKET_HOLD = '[HOLD]';
TICKET_INVOICE = '[INVOICE]';
//Totals
TICKET_NO_TAXABLE = '[NOTAXABLE]';
TICKET_TAXABLE = '[TAXABLE]';
TICKET_TAX = '[TAX]';
TICKET_SUBTOTAL = '[SUBTOTAL]';
TICKET_TOTAL = '[TOTAL]';
TICKET_CASH_RECEIVED = '[CASH]';
TICKET_CHANGE = '[CHANGE]';
TICKET_ITEM_DISCOUNT = '[ITEMDISCOUNT]';
TICKET_DISCOUNT = '[DISCOUNT]';
TICKET_REFUND = '[REFUND]';
TICKET_PAYDATE_TYPE = '[DATE/TYPE/$]';
//Layaway
TICKET_PAYMENT_TOTAL = '[PAYMENT_TOTALS]';
TICKET_PAYMENT_BALANCE = '[PAYMENT_BALANCE]';
COD_GERAL= '_COD_GERAL';
WM_Start = WM_USER+100;
INC_VALUE = '*';
DAY_ADJUST = 1 -(1/86400);
ORDER_AUTO = -1;
ORDER_ASC = 0;
ORDER_DESC = 1;
QuitacaoMeioTipo_Especie = 1;
QuitacaoMeioTipo_Cartao = 2;
QuitacaoMeioTipo_Outros = 3;
QuitacaoMeioTipo_Cheque = 4;
SIS_IDMOEDA_PADRAO = 4;
SIS_IDMOEDACOTACAO_PADRAO = 6;
ffValor = '#,##0.00;-#,##.00;0.00';
ffQtde = '#,##0.00;-#,##.00;0.00';
ffDataHora = 'ddddd hh:mm';
ffHora = '#,##0.0;-#,##.0;0.0';
ffPerc = '#,##0.00 %';
fdSQLDate = 'yyyymmdd';
MaxModulos = 200;
//Main menu navigator
WEB_PRIOR = 0;
WEB_NEXT = 1;
// Constantes do MainRetail Copatibilidade
SUGG_CLASS = 'CLASS';
SUGG_NAME = 'NAME';
SUGG_VALUE = 'VALUE';
QUICK_REP_TOTALSALES = 1;
QUICK_REP_ITEMSHOLD = 2;
QUICK_REP_ITEMSPO = 3;
implementation
end.
|
unit BCEditor.Editor.LineSpacing;
interface
uses
System.Classes, Vcl.Graphics;
type
TLineSpacingRule = (lsSingle, lsOneAndHalf, lsDouble, lsSpecified);
TBCEditorLineSpacing = class(TPersistent)
strict private
FOnChange: TNotifyEvent;
FRule: TLineSpacingRule;
FSpacing: Integer;
procedure DoChange;
procedure SetRule(const AValue: TLineSpacingRule);
procedure SetSpacing(const AValue: Integer);
public
constructor Create;
procedure Assign(ASource: TPersistent); override;
published
property Rule: TLineSpacingRule read FRule write SetRule default lsSpecified;
property Spacing: Integer read FSpacing write SetSpacing default 1;
property OnChange: TNotifyEvent read FOnChange write FOnChange;
end;
implementation
{ TBCEditorLineSpacing }
procedure TBCEditorLineSpacing.Assign(ASource: TPersistent);
begin
if Assigned(ASource) and (ASource is TBCEditorLineSpacing) then
with ASource as TBCEditorLineSpacing do
begin
Self.FSpacing := Spacing;
Self.FRule := Rule;
Self.DoChange;
end
else
inherited Assign(ASource);
end;
constructor TBCEditorLineSpacing.Create;
begin
inherited;
FSpacing := 1;
FRule := lsSpecified;
end;
procedure TBCEditorLineSpacing.DoChange;
begin
if Assigned(FOnChange) then
FOnChange(Self);
end;
procedure TBCEditorLineSpacing.SetSpacing(const AValue: Integer);
begin
if FSpacing <> AValue then
begin
FSpacing := AValue;
DoChange;
end;
end;
procedure TBCEditorLineSpacing.SetRule(const AValue: TLineSpacingRule);
begin
if FRule <> AValue then
begin
FRule := AValue;
DoChange;
end;
end;
end.
|
unit FornecedorDAO;
interface
uses
DBXCommon, SqlExpr, Fornecedor, BaseDAO;
type
TFornecedorDAO = class(TBaseDAO)
public
function List: TDBXReader;
function NextCodigo: string;
function Insert(Fornecedor: TFornecedor): Boolean;
function Update(Fornecedor: TFornecedor): Boolean;
function Delete(Fornecedor: TFornecedor): Boolean;
function FindByCodigo(Codigo: string): TFornecedor;
function ListagemFornecedores(CodigoProduto: string): TDBXReader;
end;
implementation
uses uSCPrincipal, StringUtils;
{ TFornecedorDAO }
function TFornecedorDAO.List: TDBXReader;
begin
PrepareCommand;
FComm.Text := 'SELECT * FROM FORNECEDORES';
Result := FComm.ExecuteQuery;
end;
function TFornecedorDAO.NextCodigo: string;
var
query: TSQLQuery;
begin
query := TSQLQuery.Create(nil);
try
query.SQLConnection := SCPrincipal.ConnTopCommerce;
query.SQL.Text := 'SELECT MAX(CODIGO) AS MAX_CODIGO FROM FORNECEDORES';
query.Open;
if query.FieldByName('max_codigo').IsNull then
Result := StrZero(1, 3)
else
Result := StrZero(query.FieldByName('max_codigo').AsInteger + 1, 3);
finally
query.Free;
end;
end;
function TFornecedorDAO.Insert(Fornecedor: TFornecedor): Boolean;
var
query: TSQLQuery;
begin
query := TSQLQuery.Create(nil);
try
query.SQLConnection := SCPrincipal.ConnTopCommerce;
//
query.SQL.Text := 'INSERT INTO FORNECEDORES (CODIGO, NOME, TELEFONE) VALUES (:CODIGO, :NOME, :TELEFONE)';
//
query.ParamByName('CODIGO').AsString := Fornecedor.Codigo;
query.ParamByName('NOME').AsString := Fornecedor.Nome;
query.ParamByName('TELEFONE').AsString := Fornecedor.Telefone;
//
try
query.ExecSQL;
Result := True;
except
Result := False;
end;
finally
query.Free;
end;
end;
function TFornecedorDAO.Update(Fornecedor: TFornecedor): Boolean;
var
query: TSQLQuery;
begin
query := TSQLQuery.Create(nil);
try
query.SQLConnection := SCPrincipal.ConnTopCommerce;
//
query.SQL.Text := 'UPDATE FORNECEDORES SET NOME = :NOME, TELEFONE = :TELEFONE '+
'WHERE CODIGO = :CODIGO';
//
query.ParamByName('NOME').AsString := Fornecedor.Nome;
query.ParamByName('TELEFONE').AsString := Fornecedor.Telefone;
query.ParamByName('CODIGO').AsString := Fornecedor.Codigo;
//
try
query.ExecSQL;
Result := True;
except
Result := False;
end;
finally
query.Free;
end;
end;
function TFornecedorDAO.Delete(Fornecedor: TFornecedor): Boolean;
var
query: TSQLQuery;
begin
query := TSQLQuery.Create(nil);
try
query.SQLConnection := SCPrincipal.ConnTopCommerce;
//
query.SQL.Text := 'DELETE FROM FORNECEDORES WHERE CODIGO = :CODIGO';
//
query.ParamByName('CODIGO').AsString := Fornecedor.Codigo;
//
try
query.ExecSQL;
Result := True;
except
Result := False;
end;
finally
query.Free;
end;
end;
function TFornecedorDAO.FindByCodigo(Codigo: string): TFornecedor;
var
query: TSQLQuery;
begin
query := TSQLQuery.Create(nil);
try
query.SQLConnection := SCPrincipal.ConnTopCommerce;
//
query.SQL.Text := 'SELECT * FROM FORNECEDORES WHERE CODIGO = ''' + Codigo + '''';
query.Open;
//
Result := TFornecedor.Create(query.FieldByName('CODIGO').AsString,
query.FieldByName('NOME').AsString,
query.FieldByName('TELEFONE').AsString);
finally
query.Free;
end;
end;
function TFornecedorDAO.ListagemFornecedores(CodigoProduto: string): TDBXReader;
begin
PrepareCommand;
FComm.Text := 'SELECT F.* FROM FORNECEDORES F '+
'WHERE F.CODIGO IS NOT NULL ';
if (CodigoProduto <> '') then
FComm.Text := FComm.Text + 'AND F.CODIGO IN (SELECT CODIGO_FORNECEDOR '+
'FROM FORNECEDORES_PRODUTO P '+
'WHERE P.CODIGO_PRODUTO = '''+CodigoProduto+''')';
Result := FComm.ExecuteQuery;
end;
end.
|
unit EST0001P.View;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, PesquisaBase.View, cxGraphics,
cxLookAndFeels,
cxLookAndFeelPainters, Vcl.Menus, dxSkinsCore, cxControls, cxContainer,
cxEdit, cxStyles,
cxCustomData, cxFilter, cxData, cxDataStorage, cxNavigator,
cxDataControllerConditionalFormattingRulesManagerDialog, Data.DB, cxDBData,
cxClasses,
cxGridLevel, cxGridCustomView, cxGridCustomTableView, cxGridTableView,
cxGridDBTableView, cxGrid,
cxTextEdit, Vcl.StdCtrls, cxButtons, Vcl.ExtCtrls, Base.View.Interf,
FireDAC.Stan.Intf,
FireDAC.Stan.Option, FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS,
FireDAC.Phys.Intf, ormbr.container.DataSet.interfaces,
ormbr.container.fdmemtable,
FireDAC.DApt.Intf, FireDAC.Comp.DataSet, FireDAC.Comp.Client,
TESTPRODUTO.Entidade.Model, Vcl.Grids, Vcl.DBGrids, dxBevel, cxLabel,
dxGDIPlusClasses, dxSkinDevExpressDarkStyle, dxSkinDevExpressStyle, dxSkinOffice2007Black,
dxSkinOffice2007Blue, dxSkinOffice2007Silver, dxSkinOffice2016Colorful, dxSkinOffice2016Dark,
dxSkinBlack, dxSkinDarkRoom, dxSkinSilver, dxSkinVS2010;
type
TFEST0001PView = class(TFPesquisaView, IBasePesquisaView)
FdDadosCODIGO: TStringField;
FdDadosIDPRODUTO: TIntegerField;
FdDadosDESCRICAO: TStringField;
FdDadosUNIDMEDIDA: TStringField;
FdDadosPRMEDIO_SINAPI: TCurrencyField;
VwDadosIDPRODUTO: TcxGridDBColumn;
VwDadosCODIGO_SINAPI: TcxGridDBColumn;
VwDadosDESCRICAO: TcxGridDBColumn;
VwDadosUNIDMEDIDA: TcxGridDBColumn;
VwDadosPRMEDIO_SINAPI: TcxGridDBColumn;
BtImportar: TcxButton;
FdDadosORIGEM_PRECO: TStringField;
VwDadosORIGEM_PRECO: TcxGridDBColumn;
FdDadosPRMEDIO: TCurrencyField;
VwDadosPRMEDIO: TcxGridDBColumn;
FdDadosCODIGO_SINAPI: TStringField;
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure BtNovoClick(Sender: TObject);
procedure BtAlterarClick(Sender: TObject);
procedure BtConsultarClick(Sender: TObject);
procedure BtExcluirClick(Sender: TObject);
procedure BtDuplicarClick(Sender: TObject);
procedure BtImportarClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
private
{ Private declarations }
FContainer: IContainerDataSet<TTESTPRODUTO>;
procedure listarRegistros;
procedure importarProdutos;
public
{ Public declarations }
class function New: IBasePesquisaView;
function incluirRegistro: IBasePesquisaView;
function alterarRegistro: IBasePesquisaView;
function consultarRegistro: IBasePesquisaView;
function excluirRegistro: IBasePesquisaView;
function duplicarRegistro: IBasePesquisaView;
procedure &executar;
end;
var
FEST0001PView: TFEST0001PView;
implementation
{$R *.dfm}
uses FacadeView, Tipos.Controller.Interf;
{ TFEST0001PView }
function TFEST0001PView.alterarRegistro: IBasePesquisaView;
begin
inherited;
Result := Self;
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaCadastro(tcProduto)
.operacao(FOperacao)
.registroSelecionado(FdDadosCODIGO.AsString)
.executar;
end;
procedure TFEST0001PView.BtAlterarClick(Sender: TObject);
begin
inherited;
alterarRegistro;
listarRegistros;
end;
procedure TFEST0001PView.BtConsultarClick(Sender: TObject);
begin
inherited;
consultarRegistro;
listarRegistros;
end;
procedure TFEST0001PView.BtDuplicarClick(Sender: TObject);
begin
inherited;
duplicarRegistro;
listarRegistros;
end;
procedure TFEST0001PView.BtExcluirClick(Sender: TObject);
begin
inherited;
excluirRegistro;
listarRegistros;
end;
procedure TFEST0001PView.BtImportarClick(Sender: TObject);
begin
inherited;
importarProdutos;
listarRegistros;
end;
procedure TFEST0001PView.BtNovoClick(Sender: TObject);
begin
inherited;
incluirRegistro;
listarRegistros;
end;
function TFEST0001PView.consultarRegistro: IBasePesquisaView;
begin
inherited;
Result := Self;
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaCadastro(tcProduto)
.operacao(FOperacao)
.registroSelecionado(FdDadosCODIGO.AsString)
.executar;
end;
function TFEST0001PView.duplicarRegistro: IBasePesquisaView;
begin
inherited;
Result := Self;
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaCadastro(tcProduto)
.operacao(FOperacao)
.registroSelecionado(FdDadosCODIGO.AsString)
.executar;
end;
function TFEST0001PView.excluirRegistro: IBasePesquisaView;
begin
inherited;
Result := Self;
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaCadastro(tcProduto)
.operacao(FOperacao)
.registroSelecionado(FdDadosCODIGO.AsString)
.executar;
end;
procedure TFEST0001PView.executar;
begin
Show;
end;
procedure TFEST0001PView.FormCreate(Sender: TObject);
begin
inherited;
FContainer := TContainerFDMemTable<TTESTPRODUTO>.Create(FConexao, FdDados);
end;
procedure TFEST0001PView.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
inherited;
case Key of
VK_F5:
begin
incluirRegistro;
listarRegistros;
end;
VK_F6:
begin
alterarRegistro;
listarRegistros;
end;
VK_F7:
begin
consultarRegistro;
listarRegistros;
end;
VK_F8:
begin
excluirRegistro;
listarRegistros;
end;
VK_F9:
begin
duplicarRegistro;
listarRegistros;
end;
VK_F10:
begin
importarProdutos;
listarRegistros;
end;
end;
end;
procedure TFEST0001PView.FormShow(Sender: TObject);
begin
inherited;
FCampoOrdem := 'DESCRICAO';
listarRegistros;
end;
procedure TFEST0001PView.importarProdutos;
begin
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaImportacao(tiProduto)
.executar;
end;
function TFEST0001PView.incluirRegistro: IBasePesquisaView;
begin
inherited;
Result := Self;
TFacadeView.New
.ModulosFacadeView
.EstoqueFactoryView
.exibirTelaCadastro(tcProduto)
.operacao(FOperacao)
.executar;
end;
procedure TFEST0001PView.listarRegistros;
begin
FContainer.OpenWhere('', FCampoOrdem);
controlaBotoesAtivos;
end;
class function TFEST0001PView.New: IBasePesquisaView;
begin
Result := Self.Create(nil);
end;
end.
|
unit ibSHDomain;
interface
uses
SysUtils, Classes,
SHDesignIntf,
ibSHDesignIntf, ibSHDBObject;
type
TibBTDomain = class(TibBTDBObject, IibSHDomain, IibSHFuncParam)
private
// FExistsPrecision: Boolean;
FFieldTypeID: Integer;
FSubTypeID: Integer;
FCharsetID: Integer;
FCollateID: Integer;
FArrayDimID: Integer;
FDomain: string;
FDataType: string;
FDataTypeExt: string;
FDataTypeField: string;
FDataTypeFieldExt: string;
FLength: Integer;
FPrecision: Integer;
FScale: Integer;
FNotNull: Boolean;
FNullType: string;
FSubType: string;
FSegmentSize: Integer;
FCharset: string;
FCollate: string;
FDefaultExpression: TStrings;
FCheckConstraint: TStrings;
FArrayDim: string;
FTableName: string;
FFieldDefault: TStrings;
FFieldNotNull: Boolean;
FFieldNullType: string;
FFieldCollateID: Integer;
FFieldCollate: string;
FComputedSource: TStrings;
FUseCustomValues: Boolean;
FNameWasChanged: Boolean;
FDataTypeWasChanged: Boolean;
FDefaultWasChanged: Boolean;
FCheckWasChanged: Boolean;
FNullTypeWasChanged: Boolean;
FCollateWasChanged: Boolean;
protected
function GetFieldTypeID: Integer;
procedure SetFieldTypeID(Value: Integer);
function GetSubTypeID: Integer;
procedure SetSubTypeID(Value: Integer);
function GetCharsetID: Integer;
procedure SetCharsetID(Value: Integer);
function GetCollateID: Integer;
procedure SetCollateID(Value: Integer);
function GetArrayDimID: Integer;
procedure SetArrayDimID(Value: Integer);
function GetDomain: string;
procedure SetDomain(Value: string);
function GetDataType: string;
procedure SetDataType(Value: string);
function GetDataTypeExt: string;
procedure SetDataTypeExt(Value: string);
function GetDataTypeField: string;
procedure SetDataTypeField(Value: string);
function GetDataTypeFieldExt: string;
procedure SetDataTypeFieldExt(Value: string);
function GetLength: Integer;
procedure SetLength(Value: Integer);
function GetPrecision: Integer;
procedure SetPrecision(Value: Integer);
function GetScale: Integer;
procedure SetScale(Value: Integer);
function GetNotNull: Boolean;
procedure SetNotNull(Value: Boolean);
function GetNullType: string;
procedure SetNullType(Value: string);
function GetSubType: string;
procedure SetSubType(Value: string);
function GetSegmentSize: Integer;
procedure SetSegmentSize(Value: Integer);
function GetCharset: string;
procedure SetCharset(Value: string);
function GetCollate: string;
procedure SetCollate(Value: string);
function GetDefaultExpression: TStrings;
procedure SetDefaultExpression(Value: TStrings);
function GetCheckConstraint: TStrings;
procedure SetCheckConstraint(Value: TStrings);
function GetArrayDim: string;
procedure SetArrayDim(Value: string);
function GetTableName: string;
procedure SetTableName(Value: string);
function GetFieldDefault: TStrings;
procedure SetFieldDefault(Value: TStrings);
function GetFieldNotNull: Boolean;
procedure SetFieldNotNull(Value: Boolean);
function GetFieldNullType: string;
procedure SetFieldNullType(Value: string);
function GetFieldCollateID: Integer;
procedure SetFieldCollateID(Value: Integer);
function GetFieldCollate: string;
procedure SetFieldCollate(Value: string);
function GetComputedSource: TStrings;
procedure SetComputedSource(Value: TStrings);
function GetUseCustomValues: Boolean;
procedure SetUseCustomValues(Value: Boolean);
function GetNameWasChanged: Boolean;
procedure SetNameWasChanged(Value: Boolean);
function GetDataTypeWasChanged: Boolean;
procedure SetDataTypeWasChanged(Value: Boolean);
function GetDefaultWasChanged: Boolean;
procedure SetDefaultWasChanged(Value: Boolean);
function GetCheckWasChanged: Boolean;
procedure SetCheckWasChanged(Value: Boolean);
function GetNullTypeWasChanged: Boolean;
procedure SetNullTypeWasChanged(Value: Boolean);
function GetCollateWasChanged: Boolean;
procedure SetCollateWasChanged(Value: Boolean);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
property FieldTypeID: Integer read GetFieldTypeID write SetFieldTypeID;
property SubTypeID: Integer read GetSubTypeID write SetSubTypeID;
property CharsetID: Integer read GetCharsetID write SetCharsetID;
property CollateID: Integer read GetCollateID write SetCollateID;
property ArrayDimID: Integer read GetArrayDimID write SetArrayDimID;
property DataTypeExt: string read GetDataTypeExt write SetDataTypeExt;
property DataTypeField: string read GetDataTypeField write SetDataTypeField;
property DataTypeFieldExt: string read GetDataTypeFieldExt write SetDataTypeFieldExt;
property NotNull: Boolean read GetNotNull write SetNotNull;
property TableName: string read GetTableName write SetTableName;
property FieldDefault: TStrings read GetFieldDefault write SetFieldDefault;
property FieldNotNull: Boolean read GetFieldNotNull write SetFieldNotNull;
property FieldNullType: string read GetFieldNullType write SetFieldNullType;
property FieldCollateID: Integer read GetFieldCollateID write SetFieldCollateID;
property FieldCollate: string read GetFieldCollate write SetFieldCollate;
// Other (for ibSHDDLGenerator)
property UseCustomValues: Boolean read GetUseCustomValues write SetUseCustomValues;
property NameWasChanged: Boolean read GetNameWasChanged write SetNameWasChanged;
property DataTypeWasChanged: Boolean read GetDataTypeWasChanged write SetDataTypeWasChanged;
property DefaultWasChanged: Boolean read GetDefaultWasChanged write SetDefaultWasChanged;
property CheckWasChanged: Boolean read GetCheckWasChanged write SetCheckWasChanged;
property NullTypeWasChanged: Boolean read GetNullTypeWasChanged write SetNullTypeWasChanged;
property CollateWasChanged: Boolean read GetCollateWasChanged write SetCollateWasChanged;
published
property Description;
property Domain: string read GetDomain {write SetDomain};
property DataType: string read GetDataType {write SetDataType};
property Length: Integer read GetLength {write SetLength};
property Precision: Integer read GetPrecision {write SetPrecision};
property Scale: Integer read GetScale {write SetScale};
property SubType: string read GetSubType {write SetSubType};
property SegmentSize: Integer read GetSegmentSize {write SetSegmentSize};
property ArrayDim: string read GetArrayDim {write SetArrayDim};
property Charset: string read GetCharset {write SetCharset};
property Collate: string read GetCollate {write SetCollate};
property NullType: string read GetNullType {write SetNullType};
property DefaultExpression: TStrings read GetDefaultExpression {write SetDefaultExpression};
property CheckConstraint: TStrings read GetCheckConstraint {write SetCheckConstraint};
property ComputedSource: TStrings read GetComputedSource {write SetComputedSource};
end;
TibBTSystemDomain = class(TibBTDomain, IibSHSystemDomain)
public
constructor Create(AOwner: TComponent); override;
end;
TibBTSystemGeneratedDomain = class(TibBTDomain, IibSHSystemGeneratedDomain)
public
constructor Create(AOwner: TComponent); override;
end;
TibBTField = class(TibBTDomain, IibSHField)
public
class function GetAssociationClassFnc: string; override;
end;
TibBTProcParam = class(TibBTDomain, IibSHProcParam)
public
class function GetAssociationClassFnc: string; override;
end;
implementation
uses
ibSHConsts, ibSHSQLs;
{ TibBTDomain }
constructor TibBTDomain.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FDefaultExpression := TStringList.Create;
FCheckConstraint := TStringList.Create;
FFieldDefault := TStringList.Create;
FComputedSource := TStringList.Create;
FPrecision := 15;
FScale := 2;
FDataType := Format('%s', [DataTypes[0, 1]]);
// Domain и ComputedSource это для Field, посему здесь прячем от показа в ОИ
MakePropertyInvisible('Domain');
MakePropertyInvisible('ComputedSource');
end;
destructor TibBTDomain.Destroy;
begin
FDefaultExpression.Free;
FCheckConstraint.Free;
FFieldDefault.Free;
FComputedSource.Free;
inherited Destroy;
end;
function TibBTDomain.GetFieldTypeID: Integer;
begin
Result := FFieldTypeID;
end;
procedure TibBTDomain.SetFieldTypeID(Value: Integer);
begin
FFieldTypeID := Value;
end;
function TibBTDomain.GetSubTypeID: Integer;
begin
Result := FSubTypeID;
end;
procedure TibBTDomain.SetSubTypeID(Value: Integer);
begin
FSubTypeID := Value;
end;
function TibBTDomain.GetCharsetID: Integer;
begin
Result := FCharsetID;
end;
procedure TibBTDomain.SetCharsetID(Value: Integer);
begin
FCharsetID := Value;
end;
function TibBTDomain.GetCollateID: Integer;
begin
Result := FCollateID;
end;
procedure TibBTDomain.SetCollateID(Value: Integer);
begin
FCollateID := Value;
end;
function TibBTDomain.GetArrayDimID: Integer;
begin
Result := FArrayDimID;
end;
procedure TibBTDomain.SetArrayDimID(Value: Integer);
begin
FArrayDimID := Value;
end;
function TibBTDomain.GetDomain: string;
begin
Result := FDomain;
end;
procedure TibBTDomain.SetDomain(Value: string);
begin
FDomain := Value;
end;
function TibBTDomain.GetDataType: string;
begin
Result := FDataType;
end;
procedure TibBTDomain.SetDataType(Value: string);
begin
FDataType := Value;
end;
function TibBTDomain.GetDataTypeExt: string;
begin
Result := FDataTypeExt;
end;
procedure TibBTDomain.SetDataTypeExt(Value: string);
begin
FDataTypeExt := Value;
end;
function TibBTDomain.GetDataTypeField: string;
begin
Result := FDataTypeField;
end;
procedure TibBTDomain.SetDataTypeField(Value: string);
begin
FDataTypeField := Value;
end;
function TibBTDomain.GetDataTypeFieldExt: string;
begin
Result := FDataTypeFieldExt;
end;
procedure TibBTDomain.SetDataTypeFieldExt(Value: string);
begin
FDataTypeFieldExt := Value;
end;
function TibBTDomain.GetLength: Integer;
begin
Result := FLength;
end;
procedure TibBTDomain.SetLength(Value: Integer);
begin
FLength := Value;
end;
function TibBTDomain.GetPrecision: Integer;
begin
Result := FPrecision;
end;
procedure TibBTDomain.SetPrecision(Value: Integer);
begin
FPrecision := Value;
end;
function TibBTDomain.GetScale: Integer;
begin
Result := FScale;
end;
procedure TibBTDomain.SetScale(Value: Integer);
begin
FScale := Value;
end;
function TibBTDomain.GetNotNull: Boolean;
begin
Result := FNotNull;
end;
procedure TibBTDomain.SetNotNull(Value: Boolean);
begin
FNotNull := Value;
end;
function TibBTDomain.GetNullType: string;
begin
Result := FNullType;
end;
procedure TibBTDomain.SetNullType(Value: string);
begin
FNullType := Value;
end;
function TibBTDomain.GetSubType: string;
begin
Result := FSubType;
end;
procedure TibBTDomain.SetSubType(Value: string);
begin
FSubType := Value;
end;
function TibBTDomain.GetSegmentSize: Integer;
begin
Result := FSegmentSize;
end;
procedure TibBTDomain.SetSegmentSize(Value: Integer);
begin
FSegmentSize := Value;
end;
function TibBTDomain.GetCharset: string;
begin
Result := FCharset;
end;
procedure TibBTDomain.SetCharset(Value: string);
begin
FCharset := Value;
end;
function TibBTDomain.GetCollate: string;
begin
Result := FCollate;
end;
procedure TibBTDomain.SetCollate(Value: string);
begin
FCollate := Value;
end;
function TibBTDomain.GetDefaultExpression: TStrings;
begin
Result := FDefaultExpression;
end;
procedure TibBTDomain.SetDefaultExpression(Value: TStrings);
begin
FDefaultExpression.Assign(Value);
end;
function TibBTDomain.GetCheckConstraint: TStrings;
begin
Result := FCheckConstraint;
end;
procedure TibBTDomain.SetCheckConstraint(Value: TStrings);
begin
FCheckConstraint.Assign(Value);
end;
function TibBTDomain.GetArrayDim: string;
begin
Result := FArrayDim;
end;
procedure TibBTDomain.SetArrayDim(Value: string);
begin
FArrayDim := Value;
end;
function TibBTDomain.GetTableName: string;
begin
Result := FTableName;
end;
procedure TibBTDomain.SetTableName(Value: string);
begin
FTableName := Value;
end;
function TibBTDomain.GetFieldDefault: TStrings;
begin
Result := FFieldDefault;
end;
procedure TibBTDomain.SetFieldDefault(Value: TStrings);
begin
FFieldDefault.Assign(Value);
end;
function TibBTDomain.GetFieldNotNull: Boolean;
begin
Result := FFieldNotNull;
end;
procedure TibBTDomain.SetFieldNotNull(Value: Boolean);
begin
FFieldNotNull := Value;
end;
function TibBTDomain.GetFieldNullType: string;
begin
Result := FFieldNullType;
end;
procedure TibBTDomain.SetFieldNullType(Value: string);
begin
FFieldNullType := Value;
end;
function TibBTDomain.GetFieldCollateID: Integer;
begin
Result := FFieldCollateID;
end;
procedure TibBTDomain.SetFieldCollateID(Value: Integer);
begin
FFieldCollateID := Value;
end;
function TibBTDomain.GetFieldCollate: string;
begin
Result := FFieldCollate;
end;
procedure TibBTDomain.SetFieldCollate(Value: string);
begin
FFieldCollate := Value;
end;
function TibBTDomain.GetComputedSource: TStrings;
begin
Result := FComputedSource;
end;
procedure TibBTDomain.SetComputedSource(Value: TStrings);
begin
FComputedSource.Assign(Value);
end;
function TibBTDomain.GetUseCustomValues: Boolean;
begin
Result := FUseCustomValues;
end;
procedure TibBTDomain.SetUseCustomValues(Value: Boolean);
begin
FUseCustomValues := Value;
end;
function TibBTDomain.GetNameWasChanged: Boolean;
begin
Result := FNameWasChanged;
end;
procedure TibBTDomain.SetNameWasChanged(Value: Boolean);
begin
FNameWasChanged := Value;
end;
function TibBTDomain.GetDataTypeWasChanged: Boolean;
begin
Result := FDataTypeWasChanged;
end;
procedure TibBTDomain.SetDataTypeWasChanged(Value: Boolean);
begin
FDataTypeWasChanged := Value;
end;
function TibBTDomain.GetDefaultWasChanged: Boolean;
begin
Result := FDefaultWasChanged;
end;
procedure TibBTDomain.SetDefaultWasChanged(Value: Boolean);
begin
FDefaultWasChanged := Value;
end;
function TibBTDomain.GetCheckWasChanged: Boolean;
begin
Result := FCheckWasChanged;
end;
procedure TibBTDomain.SetCheckWasChanged(Value: Boolean);
begin
FCheckWasChanged := Value;
end;
function TibBTDomain.GetNullTypeWasChanged: Boolean;
begin
Result := FNullTypeWasChanged;
end;
procedure TibBTDomain.SetNullTypeWasChanged(Value: Boolean);
begin
FNullTypeWasChanged := Value;
end;
function TibBTDomain.GetCollateWasChanged: Boolean;
begin
Result := FCollateWasChanged;
end;
procedure TibBTDomain.SetCollateWasChanged(Value: Boolean);
begin
FCollateWasChanged := Value;
end;
{ TibBTSystemDomain }
constructor TibBTSystemDomain.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
System := True;
end;
{ TibBTSystemGeneratedDomain }
constructor TibBTSystemGeneratedDomain.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
System := True;
end;
{ TibBTField }
class function TibBTField.GetAssociationClassFnc: string;
begin
Result := SClassAssocField;
end;
{ TibBTProcParam }
class function TibBTProcParam.GetAssociationClassFnc: string;
begin
Result := 'Parameter';
end;
end.
|
unit htTurboSplitter;
interface
uses
Windows, SysUtils, Types, Classes, Controls, Graphics,
htInterfaces, htTag, htMarkup, htControls, htAjaxPanel, htTurboBox;
type
ThtTurboSplitter = class(ThtTurboGraphicControl)
protected
procedure Paint; override;
public
constructor Create(inOwner: TComponent); override;
destructor Destroy; override;
procedure GenerateTag(inTag: ThtTag; inMarkup: ThtMarkup); override;
published
property Align;
//property Style;
//property Transparent;
property Visible;
end;
implementation
uses
LrVclUtils, LrControlIterator, htPaint;
{ ThtTurboSplitter }
constructor ThtTurboSplitter.Create(inOwner: TComponent);
begin
inherited;
end;
destructor ThtTurboSplitter.Destroy;
begin
inherited;
end;
procedure ThtTurboSplitter.GenerateTag(inTag: ThtTag; inMarkup: ThtMarkup);
begin
with inTag do
begin
Element := 'div';
Attributes['turboAlign'] := AlignToAjaxAlign(Align);
Attributes['dojoType'] := 'TurboSplitter';
Attributes['id'] := Name;
end;
MarkupStyles(Style.InlineAttribute, inMarkup);
//AjaxGenerateChildren(Self, inTag, inMarkup);
end;
procedure ThtTurboSplitter.Paint;
begin
Canvas.Brush.Color := clSilver;
Canvas.FillRect(BoxRect);
inherited;
end;
end.
|
unit Form.SetterAndGetterErzeugen;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, Objekt.FeldList, Objekt.Feld;
type
TForm1 = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
mem_DDL: TMemo;
btn_Erzeugen: TButton;
Label1: TLabel;
edt_Praefix: TEdit;
procedure FormCreate(Sender: TObject);
procedure btn_ErzeugenClick(Sender: TObject);
procedure FormDestroy(Sender: TObject);
private
fPraefix: string;
fPropertyList: TStringList;
fIniList: TStringList;
fSaveToDBList: TStringList;
fLoadFromQueryList: TStringList;
fPath: string;
fFeldList: TFeldList;
procedure LadeFeldList;
public
procedure Erzeugen;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
uses
db;
procedure TForm1.FormCreate(Sender: TObject);
begin
edt_Praefix.Text := 'ST';
fPath := IncludeTrailingPathDelimiter(ExtractFilePath(ParamStr(0)));
fPropertyList := TStringList.Create;
fIniList := TStringList.Create;
fSaveToDBList := TStringList.Create;
fLoadFromQueryList := TStringList.Create;
fFeldList := TFeldList.Create;
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
FreeAndNil(fIniList);
FreeAndNil(fPropertyList);
FreeAndNil(fSaveToDBList);
FreeAndNil(fFeldList);
FreeAndNil(fLoadFromQueryList);
end;
procedure TForm1.btn_ErzeugenClick(Sender: TObject);
begin
LadeFeldList;
Erzeugen;
end;
procedure TForm1.LadeFeldList;
var
i1, i2: Integer;
iPos: Integer;
s: string;
Vari: String;
First: Boolean;
Feld: TFeld;
begin
fFeldList.Clear;
fPraefix := edt_Praefix.Text;
if fPraefix[Length(fPraefix)] <> '_' then
fPraefix := fPraefix + '_';
fFeldList.Preafix := fPraefix;
for i1 := 0 to mem_DDL.Lines.Count -1 do
begin
s := mem_DDL.Lines[i1];
iPos := Pos(fPraefix, s);
if iPos <= 0 then
continue;
Vari := '';
First := true;
for i2 := 1 to Length(s) do
begin
if (s[i2] = ' ') and (First) then
continue;
First := false;
if (s[i2] = ' ') then
break;
Vari := Vari + s[i2];
if (Length(Vari) = 3) and (SameText(Vari, fPraefix)) then
Vari := '';
end;
if Vari > '' then
begin
if (Pos('INTEGER,', s) > 0)
or (Pos('INTEGER ', s) > 0)
or (Pos('CHAR(', s) > 0)
or (Pos('CHAR ', s) > 0)
or (Pos('VARCHAR(', s) > 0)
or (Pos('VARCHAR ', s) > 0)
or (Pos('BLOB S', s) > 0)
or (Pos('DATE,', s) > 0)
or (Pos('DATE ', s) > 0)
or (Pos('DOUBLE PRECISION ', s) > 0)
or (Pos('DOUBLE PRECISION,', s) > 0) then
begin
Feld := fFeldList.Add;
Feld.Name := Vari;
Feld.Typ := ftUnknown;
if (Pos('VARCHAR(', s) > 0) or (Pos('VARCHAR ', s) > 0) then
Feld.Typ := ftString;
if (Feld.Typ = ftUnknown) and (Pos('CHAR(', s) > 0) or (Pos('CHAR ', s) > 0) then
Feld.Typ := ftBoolean;
if (Pos('INTEGER,', s) > 0) or (Pos('INTEGER ', s) > 0) then
Feld.Typ := ftInteger;
if (Pos('BLOB S', s) > 0) then
Feld.Typ := ftBlob;
if (Pos('DOUBLE PRECISION,', s) > 0) or (Pos('DOUBLE PRECISION ', s) > 0) then
Feld.Typ := ftFloat;
if (Pos('DATE,', s) > 0) or (Pos('DATE ', s) > 0) then
Feld.Typ := ftDateTime;
end;
end;
end;
end;
procedure TForm1.Erzeugen;
begin
fFeldList.PropertyList(fPropertyList);
fFeldList.InitList(fIniList);
fFeldList.SaveToDBList(fSaveToDBList);
fFeldList.LoadFromQuery(fLoadFromQueryList);
fPropertyList.SaveToFile(fPath + 'Property.txt');
fIniList.SaveToFile(fPath + 'Ini.txt');
fSaveToDBList.SaveToFile(fPath + 'SaveToDB.txt');
fLoadFromQueryList.SaveToFile(fPath + 'LoadFromQuery.txt');
ShowMessage('Fertig');
end;
{
procedure TForm1.Erzeugen;
var
i1, i2: Integer;
iPos: Integer;
s: string;
Vari: String;
VariArt: string;
First: Boolean;
begin
fPropertyList.Clear;
fIniList.Clear;
fSaveToDBList.Clear;
fSaveToDBList.Add('queryBuilder');
fSaveToDBList.Add('.table(getTableName)');
fPraefix := edt_Praefix.Text;
if fPraefix[Length(fPraefix)] <> '_' then
fPraefix := fPraefix + '_';
for i1 := 0 to mem_DDL.Lines.Count -1 do
begin
s := mem_DDL.Lines[i1];
iPos := Pos(fPraefix, s);
if iPos <= 0 then
continue;
Vari := '';
First := true;
for i2 := 1 to Length(s) do
begin
if (s[i2] = ' ') and (First) then
continue;
First := false;
if (s[i2] = ' ') then
break;
Vari := Vari + s[i2];
if (Length(Vari) = 3) and (SameText(Vari, fPraefix)) then
Vari := '';
end;
if Vari > '' then
begin
if Pos('INTEGER', s) > 0 then
VariArt := 'Integer';
if Pos('CHAR', s) > 0 then
VariArt := 'String';
if Pos('DOUBLE PRECISION', s) > 0 then
VariArt := 'Real';
s := 'property ' + Vari + ': ' + VariArt + ' read f' + Vari + ' write set' + Vari;
fPropertyList.Add(s);
s := 'f' + Vari + ' := ';
if (VariArt = 'Integer') or (VariArt = 'Real') then
s := s + '0;';
if (VariArt = 'String') then
s := s + QuotedStr('') + ';';
fIniList.Add(s);
s := '.field(' + '''' + fPraefix + Vari + '''' + ', f' + Vari + ')';
fSaveToDBList.Add(s);
end;
end;
fPropertyList.SaveToFile(fPath + 'Property.txt');
fIniList.SaveToFile(fPath + 'Ini.txt');
fSaveToDBList.SaveToFile(fPath + 'SaveToDB.txt');
ShowMessage('Fertig');
end;
}
end.
|
{******************************************************************************}
{ }
{ Delphi OPENSSL Library }
{ Copyright (c) 2016 Luca Minuti }
{ https://bitbucket.org/lminuti/delphi-openssl }
{ }
{******************************************************************************}
{ }
{ Licensed under the Apache License, Version 2.0 (the "License"); }
{ you may not use this file except in compliance with the License. }
{ You may obtain a copy of the License at }
{ }
{ http://www.apache.org/licenses/LICENSE-2.0 }
{ }
{ Unless required by applicable law or agreed to in writing, software }
{ distributed under the License is distributed on an "AS IS" BASIS, }
{ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. }
{ See the License for the specific language governing permissions and }
{ limitations under the License. }
{ }
{******************************************************************************}
// enc - symmetric cipher routines
// https://www.openssl.org/docs/manmaster/apps/enc.html
unit OpenSSL.SMIMEUtils;
interface
uses
System.SysUtils, System.Classes, OpenSSL.Core;
type
TSMIMEUtil = class(TOpenSSLBase)
public
function Decrypt(InputStream, OutputStream: TStream; Verify, NoVerify: Boolean): Integer;
end;
implementation
uses
OpenSSL.Api_11;
type
TC_INT = LongInt;
TC_LONG = LongInt;
TC_ULONG = LongWord;
BIO_METHOD = record
_type : TC_INT;
name : PAnsiChar;
bwrite : function(_para1 : PBIO; _para2 : PAnsiChar; _para3 : TC_Int) : TC_Int; cdecl;
bread : function(_para1: PBIO; _para2: PAnsiChar; _para3: TC_Int) : TC_Int; cdecl;
bputs : function (_para1 : PBIO; _para2 : PAnsiChar) : TC_Int; cdecl;
bgets : function (_para1 : PBIO; _para2 : PAnsiChar; _para3 : TC_Int) : TC_Int; cdecl;
ctrl : function (_para1 : PBIO; _para2 : TC_Int; _para3 : TC_LONG; _para4 : Pointer) : TC_LONG; cdecl;
create : function(_para1 : PBIO) : TC_Int; cdecl;
destroy : function (_para1 : PBIO) : TC_Int; cdecl;
callback_ctrl : function (_para1 : PBIO; _para2 : TC_Int; _para3 : pbio_info_cb): TC_LONG; cdecl;
end;
BIO = record
method : PBIO_METHOD;
callback : function (_para1 : PBIO; _para2 : TC_INT; _para3 : PAnsiChar;
_para4 : TC_INT; _para5, _para6 : TC_LONG) : TC_LONG cdecl;
cb_arg : PAnsiChar;
init : TC_INT;
shutdown : TC_INT;
flags : TC_INT;
retry_reason : TC_INT;
num : TC_INT;
ptr : Pointer;
next_bio : PBIO;
prev_bio : PBIO;
references : TC_INT;
num_read : TC_ULONG;
num_write : TC_ULONG;
ex_data : CRYPTO_EX_DATA;
end;
PBIO = ^BIO;
{ TSMIMEUtil }
function TSMIMEUtil.Decrypt(InputStream, OutputStream: TStream; Verify, NoVerify: Boolean): Integer;
var
LInput, LOutput, LContent: PBIO;
LPKCS7: PPKCS7;
LStore: PX509_STORE;
LCerts: PSTACK_OF_X509;
LFlags, LOutputLen: Integer;
LOutputBuffer, LInputBuffer: TBytes;
begin
Result := 0;
LFlags := 0;
if NoVerify then
LFlags := PKCS7_NOVERIFY;
LContent := nil;
LCerts := nil;
LInput := nil;
LOutput := nil;
LStore := X509_STORE_new();
try
SetLength(LInputBuffer, InputStream.Size);
InputStream.ReadBuffer(LInputBuffer[0], InputStream.Size);
LInput := BIO_new_mem_buf(LInputBuffer, InputStream.Size);
if not Assigned(LInput) then
RaiseOpenSSLError('BIO_new_file');
LPKCS7 := nil;
LPKCS7 := d2i_PKCS7_bio(LInput, @LPKCS7);
if not Assigned(LPKCS7) then
RaiseOpenSSLError('FSMIME_read_PKCS7');
LOutput := BIO_new(BIO_s_mem());
if not Assigned(LOutput) then
RaiseOpenSSLError('BIO_new');
if Verify then
begin
Result := PKCS7_verify(LPKCS7, LCerts, LStore, LContent, LOutput, LFlags);
if Assigned(LOutput) and Assigned(OutputStream) then
begin
LOutputLen := LOutput.num_write;
SetLength(LOutputBuffer, LOutputLen);
BIO_read(LOutput, LOutputBuffer, LOutputLen);
OutputStream.WriteBuffer(LOutputBuffer, LOutputLen);
end;
end;
finally
BIO_free(LInput);
BIO_free(LOutput);
BIO_free(LContent);
end;
end;
end.
|
unit SyntaxHighlighter;
interface
uses
SysUtils,Windows,Classes,Graphics;
type
TLineClass=Byte;
TCharClass=Byte;
TCharClassArray=array[0..$FFFF] of TCharClass;
PCharClassArray=^TCharClassArray;
TCharClassHighlight=record
BackgroundColor,FontColor:TColor;
FontStyle:TFontStyles;
end;
TCustomSyntaxHighlighter=class(TComponent)
private
protected
function GetCharClassHighlight(Index: TCharClass): TCharClassHighlight;virtual;abstract;
function GetHighlightClassCount: Integer;virtual;
function GetHighlightClassHasText(Index: Integer): Boolean;virtual;
function GetHighlightClassName(Index: Integer): string;virtual;
function GetHighlightData(Index: Integer): TCharClassHighlight;virtual;
procedure SetHighlightData(Index: Integer; const Value: TCharClassHighlight);virtual;
public
procedure TokenizeLineClass(const LastLineClass:TLineClass;var NewLineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer);virtual;abstract;
procedure TokenizeLine(const LineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer;CharClass:PCharClassArray);virtual;abstract;
property CharClassHighlight[Index:TCharClass]:TCharClassHighlight read GetCharClassHighlight;
function CharClassCanHint(ClassID:TCharClass):Boolean;virtual;
function CharClassHint(ClassID:TCharClass;Text:string;Pos:TPoint):string;virtual;
function CharClassCanJump(ClassID:TCharClass):Boolean;virtual;
procedure CharClassJump(ClassID:TCharClass;Text:string;Pos:TPoint);virtual;
property HighlightClassCount:Integer read GetHighlightClassCount;
property HighlightClassName[Index:Integer]:string read GetHighlightClassName;
property HighlightClassHasText[Index:Integer]:Boolean read GetHighlightClassHasText;
property HighlightData[Index:Integer]:TCharClassHighlight read GetHighlightData write SetHighlightData;
end;
TTokenizeLineClassEvent=procedure(Sender:TObject;const LastLineClass:TLineClass;var NewLineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer) of object;
TTokenizeLineEvent=procedure(Sender:TObject;const LineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer;CharClass:PCharClassArray) of object;
TGetHintEvent=procedure(Sender:TObject;var Hint:string;const Text:string;const Pos:TPoint) of object;
TJumpEvent=procedure(Sender:TObject;const Text:string;const Pos:TPoint) of object;
TCharClassHighlightItem=class(TCollectionItem)
private
FBackgroundColor: TColor;
FFontColor: TColor;
FFontStyle: TFontStyles;
FCaption: string;
FOnGetHint: TGetHintEvent;
FOnJump: TJumpEvent;
procedure SetBackgroundColor(const Value: TColor);
procedure SetFontColor(const Value: TColor);
procedure SetFontStyle(const Value: TFontStyles);
procedure SetCaption(const Value: string);
procedure SetOnGetHint(const Value: TGetHintEvent);
procedure SetOnJump(const Value: TJumpEvent);
public
function GetNamePath:string;override;
constructor Create(Collection:TCollection);override;
published
property Caption:string read FCaption write SetCaption;
property BackgroundColor:TColor read FBackgroundColor write SetBackgroundColor;
property FontColor:TColor read FFontColor write SetFontColor;
property FontStyle:TFontStyles read FFontStyle write SetFontStyle;
property OnGetHint:TGetHintEvent read FOnGetHint write SetOnGetHint;
property OnJump:TJumpEvent read FOnJump write SetOnJump;
end;
TCharClassHighlightCollection=class(TOwnedCollection)
private
function GetItem(Index: Integer): TCharClassHighlightItem;
procedure SetItem(Index: Integer;
const Value: TCharClassHighlightItem);
protected
public
property Items[Index:Integer]:TCharClassHighlightItem read GetItem write SetItem;default;
end;
TSyntaxHighlighter=class(TCustomSyntaxHighlighter)
private
FOnTokenizeLineClass: TTokenizeLineClassEvent;
FOnTokenizeLine: TTokenizeLineEvent;
FCharClassHighlights: TCharClassHighlightCollection;
procedure SetOnTokenizeLine(const Value: TTokenizeLineEvent);
procedure SetOnTokenizeLineClass(const Value: TTokenizeLineClassEvent);
function GetCharClassHighlights: TCharClassHighlightCollection;
procedure SetCharClassHighlights(
const Value: TCharClassHighlightCollection);
protected
function GetCharClassHighlight(Index: TCharClass): TCharClassHighlight;override;
function GetHighlightClassCount: Integer;override;
function GetHighlightClassHasText(Index: Integer): Boolean;override;
function GetHighlightClassName(Index: Integer): string;override;
function GetHighlightData(Index: Integer): TCharClassHighlight;override;
procedure SetHighlightData(Index: Integer; const Value: TCharClassHighlight);override;
public
constructor Create(AOwner:TComponent);override;
function CharClassCanHint(ClassID:TCharClass):Boolean;override;
function CharClassHint(ClassID:TCharClass;Text:string;Pos:TPoint):string;override;
function CharClassCanJump(ClassID:TCharClass):Boolean;override;
procedure CharClassJump(ClassID:TCharClass;Text:string;Pos:TPoint);override;
destructor Destroy;override;
published
procedure TokenizeLineClass(const LastLineClass:TLineClass;var NewLineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer);override;
procedure TokenizeLine(const LineClass:TLineClass;const TextBuffer:PChar;const TextLength:Integer;CharClass:PCharClassArray);override;
property OnTokenizeLineClass:TTokenizeLineClassEvent read FOnTokenizeLineClass write SetOnTokenizeLineClass;
property OnTokenizeLine:TTokenizeLineEvent read FOnTokenizeLine write SetOnTokenizeLine;
property CharClassHighlights:TCharClassHighlightCollection read GetCharClassHighlights write SetCharClassHighlights;
end;
implementation
{ TCustomSyntaxHighlighter }
function TCustomSyntaxHighlighter.CharClassCanHint(
ClassID: TCharClass): Boolean;
begin
Result:=False;
end;
function TCustomSyntaxHighlighter.CharClassCanJump(
ClassID: TCharClass): Boolean;
begin
Result:=False;
end;
function TCustomSyntaxHighlighter.CharClassHint(ClassID: TCharClass;
Text: string; Pos: TPoint): string;
begin
Result:='';
end;
procedure TCustomSyntaxHighlighter.CharClassJump(ClassID: TCharClass;
Text: string; Pos: TPoint);
begin
end;
function TCustomSyntaxHighlighter.GetHighlightClassCount: Integer;
begin
Result:=0;
end;
function TCustomSyntaxHighlighter.GetHighlightClassHasText(
Index: Integer): Boolean;
begin
Result:=False;
end;
function TCustomSyntaxHighlighter.GetHighlightClassName(
Index: Integer): string;
begin
Result:='';
end;
function TCustomSyntaxHighlighter.GetHighlightData(
Index: Integer): TCharClassHighlight;
begin
with Result do begin
BackgroundColor:=0;
FontColor:=0;
FontStyle:=[];
end;
end;
procedure TCustomSyntaxHighlighter.SetHighlightData(Index: Integer;
const Value: TCharClassHighlight);
begin
end;
{ TCharClassHighlightItem }
constructor TCharClassHighlightItem.Create(Collection: TCollection);
begin
inherited;
FBackgroundColor:=clWhite;
FFontColor:=0;
FFontStyle:=[];
end;
function TCharClassHighlightItem.GetNamePath: string;
begin
if FCaption<>'' then
Result:=Collection.GetNamePath+'_'+FCaption
else
Result:=inherited GetNamePath;
end;
procedure TCharClassHighlightItem.SetBackgroundColor(const Value: TColor);
begin
FBackgroundColor := Value;
end;
procedure TCharClassHighlightItem.SetCaption(const Value: string);
begin
FCaption := Value;
end;
procedure TCharClassHighlightItem.SetFontColor(const Value: TColor);
begin
FFontColor := Value;
end;
procedure TCharClassHighlightItem.SetFontStyle(const Value: TFontStyles);
begin
FFontStyle := Value;
end;
procedure TCharClassHighlightItem.SetOnGetHint(const Value: TGetHintEvent);
begin
FOnGetHint := Value;
end;
procedure TCharClassHighlightItem.SetOnJump(const Value: TJumpEvent);
begin
FOnJump := Value;
end;
{ TCharClassHighlightCollection }
function TCharClassHighlightCollection.GetItem(
Index: Integer): TCharClassHighlightItem;
begin
Result:=(inherited GetItem(Index)) as TCharClassHighlightItem;
end;
procedure TCharClassHighlightCollection.SetItem(Index: Integer;
const Value: TCharClassHighlightItem);
begin
inherited SetItem(Index,Value);
end;
{ TSyntaxHighlighter }
function TSyntaxHighlighter.CharClassCanHint(ClassID: TCharClass): Boolean;
begin
Result:=Assigned(FCharClassHighlights[ClassID].OnGetHint);
end;
function TSyntaxHighlighter.CharClassCanJump(ClassID: TCharClass): Boolean;
begin
Result:=Assigned(FCharClassHighlights[ClassID].OnJump);
end;
function TSyntaxHighlighter.CharClassHint(ClassID: TCharClass;
Text: string; Pos: TPoint): string;
begin
Result:='';
if Assigned(FCharClassHighlights[ClassID].OnGetHint) then
FCharClassHighlights[ClassID].OnGetHint(FCharClassHighlights[ClassID],Result,Text,Pos);
end;
procedure TSyntaxHighlighter.CharClassJump(ClassID: TCharClass;
Text: string; Pos: TPoint);
begin
if Assigned(FCharClassHighlights[ClassID].OnJump) then
FCharClassHighlights[ClassID].OnJump(FCharClassHighlights[ClassID],Text,Pos);
end;
constructor TSyntaxHighlighter.Create(AOwner: TComponent);
begin
inherited;
FCharClassHighlights:=TCharClassHighlightCollection.Create(Self,TCharClassHighlightItem);
end;
destructor TSyntaxHighlighter.Destroy;
begin
FCharClassHighlights.Destroy;
inherited;
end;
function TSyntaxHighlighter.GetCharClassHighlight(
Index: TCharClass): TCharClassHighlight;
begin
with FCharClassHighlights[Index],Result do begin
BackgroundColor:=FBackgroundColor;
FontColor:=FFontColor;
FontStyle:=FFontStyle;
end;
end;
function TSyntaxHighlighter.GetCharClassHighlights: TCharClassHighlightCollection;
begin
Result:=FCharClassHighlights;
end;
function TSyntaxHighlighter.GetHighlightClassCount: Integer;
begin
Result:=FCharClassHighlights.Count;
end;
function TSyntaxHighlighter.GetHighlightClassHasText(
Index: Integer): Boolean;
begin
Result:=True;
end;
function TSyntaxHighlighter.GetHighlightClassName(Index: Integer): string;
begin
Result:=FCharClassHighlights[Index].FCaption;
end;
function TSyntaxHighlighter.GetHighlightData(
Index: Integer): TCharClassHighlight;
begin
with FCharClassHighlights[Index],Result do begin
BackgroundColor:=FBackgroundColor;
FontColor:=FFontColor;
FontStyle:=FFontStyle;
end;
end;
procedure TSyntaxHighlighter.SetCharClassHighlights(
const Value: TCharClassHighlightCollection);
begin
FCharClassHighlights.Assign(Value);
end;
procedure TSyntaxHighlighter.SetHighlightData(Index: Integer;
const Value: TCharClassHighlight);
begin
with FCharClassHighlights[Index],Value do begin
FBackgroundColor:=BackgroundColor;
FFontColor:=FontColor;
FFontStyle:=FontStyle;
end;
end;
procedure TSyntaxHighlighter.SetOnTokenizeLine(
const Value: TTokenizeLineEvent);
begin
FOnTokenizeLine := Value;
end;
procedure TSyntaxHighlighter.SetOnTokenizeLineClass(
const Value: TTokenizeLineClassEvent);
begin
FOnTokenizeLineClass := Value;
end;
procedure TSyntaxHighlighter.TokenizeLine(const LineClass: TLineClass;
const TextBuffer: PChar; const TextLength: Integer;
CharClass: PCharClassArray);
begin
if Assigned(FOnTokenizeLine) then
FOnTokenizeLine(Self,LineClass,TextBuffer,TextLength,CharClass);
end;
procedure TSyntaxHighlighter.TokenizeLineClass(
const LastLineClass: TLineClass; var NewLineClass: TLineClass;
const TextBuffer: PChar; const TextLength: Integer);
begin
if Assigned(FOnTokenizeLineClass) then
FOnTokenizeLineClass(Self,LastLineClass,NewLineClass,TextBuffer,TextLength);
end;
end.
|
unit Win32.MPEG2Data;
{$mode delphi}
interface
uses
Windows, Classes, SysUtils,
Win32.MPEG2Structs;
const
IID_IMpeg2TableFilter: TGUID = '{BDCDD913-9ECD-4fb2-81AE-ADF747EA75A5}';
IID_IMpeg2Data: TGUID = '{9B396D40-F380-4e3c-A514-1A82BF6EBFE6}';
IID_ISectionList: TGUID = '{AFEC1EB5-2A64-46c6-BF4B-AE3CCB6AFDB0}';
IID_IMpeg2Stream: TGUID = '{400CC286-32A0-4ce4-9041-39571125A635}';
CLSID_Mpeg2TableFilter: TGUID = '{752845F1-758F-4c83-A043-4270C593308E}';
LIBID_Mpeg2DataLib: TGUID = '{DBAF6C1B-B6A4-4898-AE65-204F0D9509A1}';
CLSID_SectionList: TGUID = '{73DA5D04-4347-45d3-A9DC-FAE9DDBE558D}';
CLSID_Mpeg2Stream: TGUID = '{F91D96C7-8509-4d0b-AB26-A0DD10904BB7}';
CLSID_Mpeg2Data: TGUID = '{C666E115-BB62-4027-A113-82D643FE2D99}';
{$Z1}
const
MPEG_PAT_PID = $0000;
MPEG_PAT_TID = $00;
MPEG_CAT_PID = $0001;
MPEG_CAT_TID = $01;
MPEG_PMT_TID = $02;
MPEG_TSDT_PID = $0002;
MPEG_TSDT_TID = $03;
ATSC_MGT_PID = $1FFB;
ATSC_MGT_TID = $C7;
ATSC_VCT_PID = $1FFB;
ATSC_VCT_TERR_TID = $C8;
ATSC_VCT_CABL_TID = $C9;
ATSC_EIT_TID = $CB;
ATSC_ETT_TID = $CC;
ATSC_RRT_TID = $CA;
ATSC_RRT_PID = $1FFB;
ATSC_STT_PID = $1FFB;
ATSC_STT_TID = $CD;
ATSC_PIT_TID = $D0;
DVB_NIT_PID = $0010;
DVB_NIT_ACTUAL_TID = $40;
DVB_NIT_OTHER_TID = $41;
DVB_SDT_PID = $0011;
DVB_SDT_ACTUAL_TID = $42;
DVB_SDT_OTHER_TID = $46;
DVB_BAT_PID = $0011;
DVB_BAT_TID = $4A;
DVB_EIT_PID = $0012;
DVB_EIT_ACTUAL_TID = $4E;
DVB_EIT_OTHER_TID = $4F;
DVB_RST_PID = $0013;
DVB_RST_TID = $71;
DVB_TDT_PID = $0014;
DVB_TDT_TID = $70;
DVB_ST_PID_16 = $0010;
DVB_ST_PID_17 = $0011;
DVB_ST_PID_18 = $0012;
DVB_ST_PID_19 = $0013;
DVB_ST_PID_20 = $0014;
DVB_ST_TID = $72;
ISDB_ST_TID = $72;
DVB_TOT_PID = $0014;
DVB_TOT_TID = $73;
DVB_DIT_PID = $001E;
DVB_DIT_TID = $7E;
DVB_SIT_PID = $001F;
DVB_SIT_TID = $7F;
ISDB_EMM_TID = $85;
ISDB_BIT_PID = $0024;
ISDB_BIT_TID = $C4;
ISDB_NBIT_PID = $0025;
ISDB_NBIT_MSG_TID = $C5;
ISDB_NBIT_REF_TID = $C6;
ISDB_LDT_PID = $0025;
ISDB_LDT_TID = $C7;
ISDB_SDTT_PID = $0023;
ISDB_SDTT_ALT_PID = $0028;
ISDB_SDTT_TID = $C3;
ISDB_CDT_PID = $0029;
ISDB_CDT_TID = $C8;
SCTE_EAS_TID = $D8;
SCTE_EAS_IB_PID = $1FFB;
SCTE_EAS_OOB_PID = $1FFC;
type
ISectionList = interface;
IMpeg2Stream = interface;
IMpeg2TableFilter = interface(IUnknown)
['{BDCDD913-9ECD-4fb2-81AE-ADF747EA75A5}']
function AddPID(p: TPID): HResult; stdcall;
function AddTable(p: TPID; t: TTID): HResult; stdcall;
function AddExtension(p: TPID; t: TTID; e: TTEID): HResult; stdcall;
function RemovePID(p: TPID): HResult; stdcall;
function RemoveTable(p: TPID; t: TTID): HResult; stdcall;
function RemoveExtension(p: TPID; t: TTID; e: TTEID): HResult; stdcall;
end;
TMpeg2TableSampleHdr = record
SectionCount: byte;
Reserved: array[0.. 2] of byte;
SectionOffsets: Plong;
end;
PMpeg2TableSampleHdr = ^TMpeg2TableSampleHdr;
IMpeg2Data = interface(IUnknown)
['{9B396D40-F380-4e3c-A514-1A82BF6EBFE6}']
function GetSection(pid: TPID; tid: TTID; pFilter: PMPEG2_FILTER; dwTimeout: DWORD;
out ppSectionList: ISectionList): HResult; stdcall;
function GetTable(pid: TPID; tid: TTID; pFilter: PMPEG2_FILTER; dwTimeout: DWORD;
out ppSectionList: ISectionList): HResult; stdcall;
function GetStreamOfSections(pid: TPID; tid: TTID; pFilter: PMPEG2_FILTER;
hDataReadyEvent: THANDLE; out ppMpegStream: IMpeg2Stream): HResult; stdcall;
end;
ISectionList = interface(IUnknown)
['{AFEC1EB5-2A64-46c6-BF4B-AE3CCB6AFDB0}']
function Initialize(requestType: TMPEG_REQUEST_TYPE; pMpeg2Data: IMpeg2Data;
pContext: PMPEG_CONTEXT; pid: TPID; tid: TTID; pFilter: PMPEG2_FILTER;
timeout: DWORD; hDoneEvent: THANDLE): HResult; stdcall;
function InitializeWithRawSections(pmplSections: PMPEG_PACKET_LIST): HResult; stdcall;
function CancelPendingRequest(): HResult; stdcall;
function GetNumberOfSections(out pCount: word): HResult; stdcall;
function GetSectionData(sectionNumber: word; out pdwRawPacketLength: DWORD;
out ppSection: PSECTION): HResult; stdcall;
function GetProgramIdentifier(pPid: PPID): HResult; stdcall;
function GetTableIdentifier(pTableId: PTID): HResult; stdcall;
end;
IMpeg2Stream = interface(IUnknown)
['{400CC286-32A0-4ce4-9041-39571125A635}']
function Initialize(requestType: TMPEG_REQUEST_TYPE; pMpeg2Data: IMpeg2Data;
pContext: PMPEG_CONTEXT; pid: TPID; tid: TTID; pFilter: PMPEG2_FILTER;
hDataReadyEvent: THANDLE): HResult; stdcall;
function SupplyDataBuffer(pStreamBuffer: PMPEG_STREAM_BUFFER): HResult; stdcall;
end;
implementation
end.
|
(*
Category: SWAG Title: ANYTHING NOT OTHERWISE CLASSIFIED
Original name: 0026.PAS
Description: Finding Anagrams
Author: SWAG SUPPORT TEAM
Date: 08-27-93 20:00
*)
{
Program compiled and tested With BP 7.0
WARNING since this Program is not using the fastest algorithm to
find it's Anagrams, long Delays can be expected For large
input-Strings.
Test have shown the following results:
Length of Input Number of anagrams found
2 2
3 6
4 24
5 120
6 720
7 5040
As can plainly be seen from this, the number of Anagrams For a
String of length N is a direct Function of the number of Anagrams
For a String of N-1. In fact the result is f(N) = N * f(N-1).
You might have recognised the infamous FACTORIAL Function!!!
Type
MyType = LongInt;
Function NumberOfAnagrams(Var InputLen : MyType) : MyType;
Var
Temp : MyType;
begin
Temp := InputLen;
if Temp >1 then
begin
Temp := Temp - 1;
NumberOfAnagrams := InputLen * NumberOfAnagrams(Temp);
end else
NumberOfAnagrams := InputLen;
end;
The above Function has been tested and found to work up to an input
length of 12. After that, Real numbers must be used. As a side note
the Maximum value computable was 1754 With MyType defined as
Extended and Numeric-Coprocessor enabled of course. Oh and BTW, the
parameter is passed as a Var so that the Stack doesn't blow up when
you use Extended Type!!!! As a result, you can't pass N-1 to the
Function. You have to STORE N-1 in a Var and pass that as parameter.
The net effect is that With Numeric Copro enabled, at 1754 it blows
up because of a MATH OVERFLOW, not a STACK OVERFLOW!!!
Based on these findings, I assume the possible anagrams can be
computed a lot faster simply by Realising that the possible Anagrams
For an input length of (N) can be found by finding all anagrams for
an input Length of (N-1) and inserting the additional letter in each
(N) positions in those Strings. Since this can not be done
recursively in memory, the obvious solution would be to to output
the anagrams strating With the first 4 or 5 caracters to a File,
because those can be found quickly enough, and then to read in each
String and apply the following caracters to each and Repeat this
process Until the final File is produced.
Here is an example:
Anagrams For ABCD
Output Anagrams For AB to File
Giving AB and BA
read that in and apply the next letter in all possible positions
Giving
abC
aCb
Cab
&
baC
bCa
Cba
Now Apply the D to this and get
abcD
abDc
aDbc
Dabc
&
acbD
acDb
aDcb
Dacb
Etc... YOU GET THE POINT!!!
BTW Expect LARGE Files if you become too enthousiastic With this!!!
An Input of just 20 caracters long will generate a File of
2,432,902,008,176,640,000 Anagrams
That's
2.4 Quintillion Anagrams
Remember that each of those are 20 caracters long,
add Carriage-return and line-feeds and you've got yourself a
HUGE File ;-)
In fact just a 10 Caracter input length will generate 3.6 Million
Anagrams from a 10 Caracter input-String. Again add Cr-LFs and
you've got yourself a 43.5 MEGAByte File!!!!!! but consider you
are generating it from the previous File which comes to 3.5 MEG
For an Input Length of 9 and you've got yourself 45 MEG of DISK in
use For this job.
}
Uses
Strings, Crt;
Const
MaxAnagram = 1000;
Type
AnagramArray = Array[0..MaxAnagram] of Word;
AnagramStr = Array[0..MaxAnagram] of Char;
Var
Target : AnagramStr;
Size : Word;
Specimen : AnagramArray;
Index : Word;
AnagramCount : LongInt;
Procedure working;
Const
CurrentCursor : Byte = 0;
CursorArray : Array[0..3] of Char = '|/-\';
begin
CurrentCursor := Succ(CurrentCursor) mod 4;
Write(CursorArray[CurrentCursor], #13);
end;
Procedure OutPutAnagram(Target : AnagramStr;
Var Specimen : AnagramArray; Size : Word);
Var
Index : Word;
begin
For Index := 0 to (Size - 1) do
Write(Target[Specimen[Index]]);
Writeln;
end;
Function IsAnagram(Var Specimen : AnagramArray; Size : Word) : Boolean;
Var
Index1,
Index2 : Word;
Valid : Boolean;
begin
Valid := True;
Index1 := 0;
While (Index1<Pred(Size)) and Valid do
begin
Index2 := Index1 + 1;
While (Index2 < Size) and Valid do
begin
if Specimen[Index1] = Specimen[Index2] then
Valid := False;
inc(Index2);
end;
inc(Index1);
end;
IsAnagram := Valid;
end;
Procedure FindAnagrams(Target : AnagramStr;
Var Specimen : AnagramArray; Size : Word);
Var
Index : Word;
Carry : Boolean;
begin
Repeat
working;
if IsAnagram(Specimen, Size) then
begin
OutputAnagram(Target, Specimen, Size);
inc(AnagramCount);
end;
Index := 0;
Repeat
Specimen[Index] := (Specimen[Index] + 1) mod Size;
Carry := not Boolean(Specimen[Index]);
Inc(Index);
Until (not Carry) or (Index >= Size);
Until Carry and (Index >= Size);
end;
begin
ClrScr;
Write('Enter anagram Target: ');
readln(Target);
Writeln;
AnagramCount := 0;
Size := Strlen(Target);
For Index := 0 to MaxAnagram do
Specimen[Index] := 0;
For Index := 0 to Size - 1 do
Specimen[Index] := Size - Index - 1;
FindAnagrams(Target, Specimen, Size);
Writeln;
Writeln(AnagramCount, ' Anagrams found With Source ', Target);
end.
|
unit PartitionImageDLL;
interface
uses
Classes, Windows,
OTFEFreeOTFEDLL_U,
SDPartitionImage,
SDUGeneral;
type
TPartitionImageDLL = class(TSDPartitionImage)
protected
FFilename: Ansistring;
FSize: ULONGLONG;
fMountedAs: char;
FBytesPerSector: integer;
FFOTFEMountedOnPartitionMount: boolean;
public
FreeOTFEObj: TOTFEFreeOTFEDLL;
constructor Create(); override;
destructor Destroy(); override;
function DoMount(): boolean; override;
procedure DoDismount(); override;
function GetSize(): ULONGLONG; override;
// maxSize - Size of data to transfer, in *bytes*, not sectors
function ReadConsecutiveSectors(startSectorID: uint64; sectors: TStream; maxSize: integer = -1): boolean; override;
// maxSize - Size of data to transfer, in *bytes*, not sectors
function WriteConsecutiveSectors(startSectorID: uint64; sectors: TStream; maxSize: integer = -1): boolean; override;
published
property Filename: Ansistring read FFilename write FFilename;
property MountedAs: char read fMountedAs write FMountedAs;
end;
implementation
uses
Math,
SDUClasses;
constructor TPartitionImageDLL.Create();
begin
inherited;
FMountedAs := #0;
FSize := 0;
end;
destructor TPartitionImageDLL.Destroy();
begin
//lplp - TO IMPLEMENT
inherited;
end;
function TPartitionImageDLL.DoMount(): boolean;
var
diskGeometry: TSDUDiskGeometry;
begin
Result := FALSE;
FFOTFEMountedOnPartitionMount := TRUE;
if (FMountedAs = #0) then
begin
FFOTFEMountedOnPartitionMount := FALSE;
FMountedAs := FreeOTFEObj.Mount(Filename);
end;
if (FMountedAs = #0) then
begin
FBytesPerSector := 0;
end
else
begin
if FreeOTFEObj.GetDiskGeometry(FMountedAs, diskGeometry) then
begin
FBytesPerSector := diskGeometry.BytesPerSector;
FSize := (
diskGeometry.Cylinders.QuadPart *
diskGeometry.TracksPerCylinder *
diskGeometry.SectorsPerTrack *
diskGeometry.BytesPerSector
);
Result := TRUE;
end
else
begin
// Dismount, but otherwise do nothing; Result already set to FALSE
DoDismount();
end;
end;
end;
procedure TPartitionImageDLL.DoDismount();
begin
// If this object mounted the FreeOTFE volume when this object was mounted,
// this object dismounts the volume
// This is so that if the volume was mounted by the *caller* (not this
// object), mounted as a partition, dismounted as a partition, then it
// FreeOTFE keeps the volume mounted - it's for the *caller* to dismount it, not us
if not(FFOTFEMountedOnPartitionMount) then
begin
FreeOTFEObj.Dismount(FMountedAs);
end;
FMountedAs := #0;
end;
// maxSize - Size of data to transfer, in *bytes*, not sectors
function TPartitionImageDLL.ReadConsecutiveSectors(startSectorID: uint64; sectors: TStream; maxSize: integer = -1): boolean;
begin
// Short circuit...
if (maxSize = 0) then
begin
Result := TRUE;
exit;
end;
if (maxSize <= 0) then
begin
maxSize := FBytesPerSector;
end;
Result := FreeOTFEObj.ReadData_Bytes(
FMountedAs,
(startSectorID * FBytesPerSector),
maxSize,
sectors
);
end;
// maxSize - Size of data to transfer, in *bytes*, not sectors
function TPartitionImageDLL.WriteConsecutiveSectors(startSectorID: uint64; sectors: TStream; maxSize: integer = -1): boolean;
begin
// Short circuit...
if (maxSize = 0) then
begin
Result := TRUE;
exit;
end;
if (maxSize <= 0) then
begin
maxSize := FBytesPerSector;
end;
Result := FreeOTFEObj.WriteData_Bytes(
FMountedAs,
(startSectorID * FBytesPerSector),
maxSize,
sectors
);
end;
function TPartitionImageDLL.GetSize(): ULONGLONG;
begin
Result := FSize;
end;
END.
|
unit UDSQLQuery;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, UCrpe32;
type
TCrpeSQLQueryDlg = class(TForm)
pnlSQLQuery: TPanel;
lblSQLQuery: TLabel;
memoSQL: TMemo;
btnOk: TButton;
btnCancel: TButton;
btnConnect: TButton;
btnClear: TButton;
btnRetrieve: TButton;
procedure memoSQLChange(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure FormShow(Sender: TObject);
procedure UpdateQuery;
procedure btnConnectClick(Sender: TObject);
procedure btnOkClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure btnCancelClick(Sender: TObject);
procedure InitializeControls(OnOff: boolean);
procedure btnClearClick(Sender: TObject);
procedure btnRetrieveClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
Cr : TCrpe;
rQuery : TStringList;
end;
var
CrpeSQLQueryDlg: TCrpeSQLQueryDlg;
bSQLQuery : boolean;
implementation
{$R *.DFM}
uses UCrpeUtl, UDConnect;
{------------------------------------------------------------------------------}
{ FormCreate }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.FormCreate(Sender: TObject);
begin
bSQLQuery := True;
LoadFormPos(Self);
btnOk.Tag := 1;
btnCancel.Tag := 1;
end;
{------------------------------------------------------------------------------}
{ FormShow }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.FormShow(Sender: TObject);
begin
rQuery := TStringList.Create;
rQuery.Assign(Cr.SQL.Query);
UpdateQuery;
end;
{------------------------------------------------------------------------------}
{ UpdateQuery }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.UpdateQuery;
var
OnOff : boolean;
begin
{Enable/Disable controls}
OnOff := not IsStrEmpty(Cr.ReportName);
InitializeControls(OnOff);
if OnOff then
begin
memoSQL.OnChange := nil;
memoSQL.Lines.Assign(Cr.SQL.Query);
memoSQL.OnChange := memoSQLChange;
end;
end;
{------------------------------------------------------------------------------}
{ InitializeControls }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.InitializeControls(OnOff: boolean);
var
i : integer;
begin
{Enable/Disable the Form Controls}
for i := 0 to ComponentCount - 1 do
begin
if TComponent(Components[i]).Tag = 0 then
begin
if Components[i] is TButton then
TButton(Components[i]).Enabled := OnOff;
if Components[i] is TMemo then
begin
TMemo(Components[i]).Clear;
TMemo(Components[i]).Color := ColorState(OnOff);
TMemo(Components[i]).Enabled := OnOff;
end;
end;
end;
end;
{------------------------------------------------------------------------------}
{ memoSQLChange }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.memoSQLChange(Sender: TObject);
begin
Cr.SQL.Query.Assign(memoSQL.Lines);
end;
{------------------------------------------------------------------------------}
{ btnConnectClick }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.btnConnectClick(Sender: TObject);
begin
CrpeConnectDlg := TCrpeConnectDlg.Create(Application);
CrpeConnectDlg.Cr := Cr;
CrpeConnectDlg.ShowModal;
end;
{------------------------------------------------------------------------------}
{ btnRetrieveClick }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.btnRetrieveClick(Sender: TObject);
begin
Cr.SQL.Retrieve;
UpdateQuery;
end;
{------------------------------------------------------------------------------}
{ btnClearClick }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.btnClearClick(Sender: TObject);
begin
Cr.SQL.Clear;
UpdateQuery;
end;
{------------------------------------------------------------------------------}
{ btnOkClick }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.btnOkClick(Sender: TObject);
begin
SaveFormPos(Self);
Close;
end;
{------------------------------------------------------------------------------}
{ btnCancelClick }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.btnCancelClick(Sender: TObject);
begin
Close;
end;
{------------------------------------------------------------------------------}
{ FormClose }
{------------------------------------------------------------------------------}
procedure TCrpeSQLQueryDlg.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
{Restore Settings}
if ModalResult = mrCancel then
Cr.SQL.Query.Assign(rQuery);
rQuery.Free;
bSQLQuery := False;
Release;
end;
end.
|
unit VoxelUndoEngine;
interface
uses BasicMathsTypes, BasicDataTypes, BasicVXLSETypes, Voxel, Voxel_Engine;
Type
TUndo_Redo_Voxel_Data = record
Pos : TVector3i;
V : TVoxelUnpacked;
end;
TUndo_Redo_Section_Data = record
XSize, YSize, ZSize: integer;
Data : array of TUndo_Redo_Voxel_Data;
Data_no : integer;
end;
TUndo_Redo = record
Data : array of TUndo_Redo_Section_Data;
Data_no : integer;
end;
Var
Undo,Redo : TUndo_Redo;
Const
Max_Undos = 10;
Function CreateRestorePoint(const _TempView : TTempView; var _Undo_Redo : TUndo_Redo): Boolean;
Procedure UndoRestorePoint(var _URUndo,_URRedo : TUndo_Redo);
Procedure RedoRestorePoint(var _URUndo,_URRedo : TUndo_Redo);
Function IsUndoRedoUsed(const _Undo_Redo : TUndo_Redo) : boolean;
Procedure ResetUndoRedo;
Procedure ResetUndo(var _Undo_Redo : TUndo_Redo);
// Bad but only way to do some restore points(i.e flips, nudges, mirroring)
Procedure CreateVXLRestorePoint(const _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
Procedure SaveVXLRestorePoint(const _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
Procedure LoadVXLRestorePoint(var _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
Procedure GoneOverReset(Var _Undo_Redo : TUndo_Redo);
implementation
uses FormMain;
Function CreateRestorePoint(const _TempView : TTempView; var _Undo_Redo : TUndo_Redo): Boolean;
var
i,no : integer;
v : TVoxelUnpacked;
begin
Result := false;
if _TempView.Data_no < 1 then
exit;
if _Undo_Redo.Data_no > Max_Undos then
GoneOverReset(_Undo_Redo);
ResetUndo(Redo);
inc(_Undo_Redo.Data_no);
SetLength(_Undo_Redo.Data,_Undo_Redo.Data_no);
_Undo_Redo.Data[_Undo_Redo.Data_no-1].XSize := FrmMain.Document.ActiveSection^.Tailer.XSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].YSize := FrmMain.Document.ActiveSection^.Tailer.YSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].ZSize := FrmMain.Document.ActiveSection^.Tailer.ZSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no := 0;
SetLength(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data,_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no);
for i := 1 to _TempView.Data_no do
begin
if _TempView.Data[i].VU then
begin
inc(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no);
no := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no - 1;
SetLength(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data, no + 1);
with _TempView do
FrmMain.Document.ActiveSection^.GetVoxel(Data[i].VC.X,Data[i].VC.Y,Data[i].VC.Z,v);
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Colour := V.Colour;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Flags := V.Flags;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Normal := V.Normal;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Used := V.Used;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.X := _TempView.Data[i].VC.X;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.Y := _TempView.Data[i].VC.Y;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.Z := _TempView.Data[i].VC.Z;
end;
end;
FrmMain.SetVoxelChanged(true);
Result := true;
end;
Procedure UndoRestorePoint(var _URUndo,_URRedo : TUndo_Redo);
begin
SaveVXLRestorePoint(FrmMain.Document.ActiveSection^, _URRedo);
LoadVXLRestorePoint(FrmMain.Document.ActiveSection^, _URUndo);
end;
Procedure RedoRestorePoint(var _URUndo,_URRedo : TUndo_Redo);
begin
SaveVXLRestorePoint(FrmMain.Document.ActiveSection^, _URUndo);
LoadVXLRestorePoint(FrmMain.Document.ActiveSection^, _URRedo);
end;
Function IsUndoRedoUsed(const _Undo_Redo : TUndo_Redo) : boolean;
begin
if _Undo_Redo.Data_no > 0 then
Result := true
else
Result := false;
end;
Procedure ResetUndoRedo;
begin
ResetUndo(Undo);
ResetUndo(Redo);
end;
procedure ResetUndo(Var _Undo_Redo : TUndo_Redo);
var
i: integer;
begin
for i := Low(_Undo_Redo.Data) to High(_Undo_Redo.Data) do
begin
SetLength(_Undo_Redo.Data[i].Data, 0);
end;
SetLength(_Undo_Redo.Data, 0);
_Undo_Redo.Data_no := 0;
end;
Procedure CreateVXLRestorePoint(const _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
begin
ResetUndo(Redo);
SaveVXLRestorePoint(_Vxl, _Undo_Redo);
end;
Procedure SaveVXLRestorePoint(const _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
var
x,y,z,no : integer;
v : TVoxelUnpacked;
begin
if _Undo_Redo.Data_no > Max_Undos then
GoneOverReset(_Undo_Redo);
inc(_Undo_Redo.Data_no);
SetLength(_Undo_Redo.Data,_Undo_Redo.Data_no);
_Undo_Redo.Data[_Undo_Redo.Data_no-1].XSize := _VXL.Tailer.XSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].YSize := _VXL.Tailer.YSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].ZSize := _VXL.Tailer.ZSize;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no := 0;
SetLength(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data, _VXL.Tailer.XSize * _VXL.Tailer.YSize * _VXL.Tailer.ZSize);
for x := 0 to _VXL.Tailer.XSize-1 do
for y := 0 to _VXL.Tailer.YSize-1 do
for z := 0 to _VXL.Tailer.ZSize-1 do
begin
inc(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no);
no := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no - 1;
_VXL.GetVoxel(x,y,z,v);
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Colour := V.Colour;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Flags := V.Flags;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Normal := V.Normal;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].V.Used := V.Used;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.X := x;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.Y := y;
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[no].Pos.Z := z;
end;
FrmMain.SetVoxelChanged(true);
end;
Procedure LoadVXLRestorePoint(var _Vxl : TVoxelSection; var _Undo_Redo : TUndo_Redo);
var
i : integer;
v : TVoxelUnpacked;
begin
if (_VXL.Tailer.XSize <> _Undo_Redo.Data[_Undo_Redo.Data_no-1].XSize) or (_VXL.Tailer.YSize <> _Undo_Redo.Data[_Undo_Redo.Data_no-1].YSize) or (_VXL.Tailer.ZSize <> _Undo_Redo.Data[_Undo_Redo.Data_no-1].ZSize) then
begin
_VXL.Resize(_Undo_Redo.Data[_Undo_Redo.Data_no-1].XSize, _Undo_Redo.Data[_Undo_Redo.Data_no-1].YSize, _Undo_Redo.Data[_Undo_Redo.Data_no-1].ZSize);
end;
for i := 0 to _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no-1 do
begin
v.Colour := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].V.Colour;
v.Flags := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].V.Flags;
v.Normal := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].V.Normal;
v.Used := _Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].V.Used;
_VXL.SetVoxel(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].Pos.X,_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].Pos.Y,_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data[i].Pos.Z, v);
end;
SetLength(_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data, 0);
_Undo_Redo.Data[_Undo_Redo.Data_no-1].Data_no := 0;
dec(_Undo_Redo.Data_no);
SetLength(_Undo_Redo.Data,_Undo_Redo.Data_no);
FrmMain.SetVoxelChanged(true);
end;
Procedure Copy_UndoRedo(Const _Source : TUndo_Redo; Var _Dest : TUndo_Redo);
var
I,J : integer;
begin
_Dest.Data_no := _Source.Data_no;
SetLength(_Dest.Data,_Dest.Data_no);
for i := 0 to _Source.Data_no-1 do
begin
_Dest.Data[i].XSize := _Source.Data[i].XSize;
_Dest.Data[i].YSize := _Source.Data[i].YSize;
_Dest.Data[i].ZSize := _Source.Data[i].ZSize;
_Dest.Data[i].Data_no := _Source.Data[i].Data_no;
SetLength(_Dest.Data[i].Data,_Dest.Data[i].Data_no);
For j := 0 to _Source.Data[i].Data_no-1 do
begin
_Dest.Data[i].Data[j].Pos.X := _Source.Data[i].Data[j].Pos.X;
_Dest.Data[i].Data[j].Pos.Y := _Source.Data[i].Data[j].Pos.Y;
_Dest.Data[i].Data[j].Pos.Z := _Source.Data[i].Data[j].Pos.Z;
_Dest.Data[i].Data[j].V.Colour := _Source.Data[i].Data[j].V.Colour;
_Dest.Data[i].Data[j].V.Normal := _Source.Data[i].Data[j].V.Normal;
_Dest.Data[i].Data[j].V.Flags := _Source.Data[i].Data[j].V.Flags;
_Dest.Data[i].Data[j].V.Used := _Source.Data[i].Data[j].V.Used;
end;
end;
end;
Procedure Copy_UndoRedo2(Const _Source : TUndo_Redo; Var _Dest : TUndo_Redo);
var
I,J : integer;
begin
_Dest.Data_no := _Source.Data_no-1;
SetLength(_Dest.Data,_Dest.Data_no);
for i := 1 to _Source.Data_no-1 do
begin
_Dest.Data[i-1].XSize := _Source.Data[i].XSize;
_Dest.Data[i-1].YSize := _Source.Data[i].YSize;
_Dest.Data[i-1].ZSize := _Source.Data[i].ZSize;
_Dest.Data[i-1].Data_no := _Source.Data[i].Data_no;
SetLength(_Dest.Data[i-1].Data,_Dest.Data[i-1].Data_no);
For j := 0 to _Source.Data[i].Data_no-1 do
begin
_Dest.Data[i-1].Data[j].Pos.X := _Source.Data[i].Data[j].Pos.X;
_Dest.Data[i-1].Data[j].Pos.Y := _Source.Data[i].Data[j].Pos.Y;
_Dest.Data[i-1].Data[j].Pos.Z := _Source.Data[i].Data[j].Pos.Z;
_Dest.Data[i-1].Data[j].V.Colour := _Source.Data[i].Data[j].V.Colour;
_Dest.Data[i-1].Data[j].V.Normal := _Source.Data[i].Data[j].V.Normal;
_Dest.Data[i-1].Data[j].V.Flags := _Source.Data[i].Data[j].V.Flags;
_Dest.Data[i-1].Data[j].V.Used := _Source.Data[i].Data[j].V.Used;
end;
end;
end;
// Should reduce the undo making it have Max_Undos
Procedure GoneOverReset(Var _Undo_Redo : TUndo_Redo);
Var
UndoT : TUndo_Redo;
begin
Copy_UndoRedo(_Undo_Redo,UndoT);
ResetUndoRedo;
Copy_UndoRedo2(UndoT,_Undo_Redo);
ResetUndo(UndoT);
end;
begin
ResetUndoRedo;
end.
|
unit Unit3;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Data.DB, Vcl.Grids, Vcl.DBGrids,
Vcl.StdCtrls, Vcl.Buttons, StrUtils, Vcl.Menus, Vcl.ExtCtrls,
Vcl.Imaging.pngimage, Vcl.Imaging.jpeg, Vcl.ExtDlgs;
type
TForm3 = class(TForm)
DBGrid1: TDBGrid;
grpManutencao: TGroupBox;
Label1: TLabel;
edtDescricao: TEdit;
Label2: TLabel;
edtQtdPassageiros: TEdit;
checkDesativar: TCheckBox;
PopupMenu1: TPopupMenu;
mnuAlterar: TMenuItem;
edtID: TEdit;
Label3: TLabel;
btnIncluir: TBitBtn;
btnCancelar: TBitBtn;
edtValorPorQuilometro: TEdit;
Label4: TLabel;
Image1: TImage;
Image2: TImage;
BalloonHint1: TBalloonHint;
Image3: TImage;
Button1: TButton;
Button2: TButton;
OpenPictureDialog1: TOpenPictureDialog;
Panel1: TPanel;
Label5: TLabel;
procedure btnIncluirClick(Sender: TObject);
procedure btnCancelarClick(Sender: TObject);
procedure mnuAlterarClick(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
{ Private declarations }
sql : string;
public
{ Public declarations }
end;
var
Form3: TForm3;
implementation
{$R *.dfm}
uses Unit4, Unit1;
procedure TForm3.btnIncluirClick(Sender: TObject);
begin
if edtDescricao.Text = '' then
begin
ShowMessage('Preencha o campo com a Descrição!');
edtDescricao.SetFocus;
exit;
end;
if edtQtdPassageiros.Text = '' then
begin
ShowMessage('Preencha o campo com a Quantdade de Passageiros!');
edtQtdPassageiros.SetFocus;
exit;
end;
if edtValorPorQuilometro.Text = '' then
begin
ShowMessage('Preencha o campo com o Velor p/ KM!');
edtValorPorQuilometro.SetFocus;
exit;
end;
if grpManutencao.Tag = 2 then
begin
dtmPrincipal.SQL.Active := false;
// Monta o SQL
sql := 'UPDATE FROTA ' +
'SET DESCRICAO = ' + QuotedStr(edtDescricao.Text) + ', ' +
'QTDE_PASSAGEIROS = ' + edtQtdPassageiros.Text + ', ' +
'ATIVO = ' + IfThen(checkDesativar.Checked, QuotedStr('DESATIVADO'), QuotedStr('ATIVO')) + ', ' +
'VALOR_KM = ' + StringReplace(edtValorPorQuilometro.Text, ',', '.', [rfReplaceAll]) + ' ' +
IfThen(OpenPictureDialog1.FileName <> '', ', IMAGEM = (:par_imagem) ', ', IMAGEM = null ') +
'WHERE ID = ' + edtID.Text;
// Atualiza o Comand
dtmPrincipal.SQL.DataSet.CommandText := sql;
// Verifica se a imagem foi selecionada
if OpenPictureDialog1.FileName <> '' then
begin
dtmPrincipal.SQL.DataSet.ParamByName('par_imagem').LoadFromFile(OpenPictureDialog1.FileName, ftBlob);
end;
// Executa a Sql
dtmPrincipal.SQL.Execute;
end;
// Verifica se está no modo Inclusão
if grpManutencao.Tag = 1 then
begin
dtmPrincipal.SQL.Active := false;
// Monta o SQL
sql := 'INSERT INTO FROTA (DESCRICAO, QTDE_PASSAGEIROS, ATIVO, VALOR_KM '+ IfThen(OpenPictureDialog1.FileName <> '', ', IMAGEM ', ' ')+ ') ' +
'VALUES (' + QuotedStr(edtDescricao.Text) + ', ' +
edtQtdPassageiros.Text + ', ' +
IfThen(checkDesativar.Checked, QuotedStr('DESATIVADO'), QuotedStr('ATIVO')) + ', ' +
StringReplace(edtValorPorQuilometro.Text, ',', '.', [rfReplaceAll]) + ' ' +
IfThen(OpenPictureDialog1.FileName <> '', ', :par_imagem ', ' ') + ' )';
// Atualiza o Comand
dtmPrincipal.SQL.DataSet.CommandText := sql;
// Verifica se a imagem foi selecionada
if OpenPictureDialog1.FileName <> '' then
begin
dtmPrincipal.SQL.DataSet.ParamByName('par_imagem').LoadFromFile(OpenPictureDialog1.FileName, ftBlob);
end;
// Executa a Sql
dtmPrincipal.SQL.Execute;
end;
// Atualiza os campos
btnCancelar.OnClick(Sender);
end;
procedure TForm3.Button1Click(Sender: TObject);
begin
// Limpa a imagem
Image1.Picture := nil;
end;
procedure TForm3.Button2Click(Sender: TObject);
begin
if (OpenPictureDialog1.Execute = false) then
exit;
Self.Image1.Picture.LoadFromFile(OpenPictureDialog1.FileName);
end;
procedure TForm3.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Form1.AtualizaTela(Sender);
end;
procedure TForm3.FormShow(Sender: TObject);
begin
edtID.Clear;
edtDescricao.Clear;
edtQtdPassageiros.Clear;
edtValorPorQuilometro.Clear;
// Limpa a imagem
Image1.Picture := nil;
// Atualiza o Grid
dtmPrincipal.qryBuscaFrota.Active := false;
dtmPrincipal.qryBuscaFrota.Active := true;
end;
procedure TForm3.btnCancelarClick(Sender: TObject);
begin
// Limpa os campos
edtDescricao.Clear;
edtQtdPassageiros.Clear;
edtID.Clear;
edtValorPorQuilometro.Clear;
checkDesativar.Checked := false;
// Atualiza o Grid
dtmPrincipal.qryBuscaFrota.Active := false;
dtmPrincipal.qryBuscaFrota.Active := true;
// Limpa a imagem
Image1.Picture := nil;
// Atualiza o group box
grpManutencao.Caption := 'Inclusão';
grpManutencao.Tag := 1;
btnIncluir.Caption := 'Inserir';
edtDescricao.SetFocus;
end;
procedure TForm3.mnuAlterarClick(Sender: TObject);
begin
// Atualiza o group box
grpManutencao.Caption := 'Alteração';
grpManutencao.Tag := 2;
btnIncluir.Caption := 'Atualizar';
// Atualiza os edit
edtID.Text := dtmPrincipal.qryBuscaFrotaID.AsString;
edtDescricao.Text := dtmPrincipal.qryBuscaFrotaDESCRICAO.AsString;
edtQtdPassageiros.Text := dtmPrincipal.qryBuscaFrotaQTDE_PASSAGEIROS.AsString;
edtValorPorQuilometro.Text := dtmPrincipal.qryBuscaFrotaVALOR_KM.AsString;
// Verifica se possui imagem
if dtmPrincipal.qryBuscaFrotaIMAGEM.AsString <> '' then
begin
TBlobField(dtmPrincipal.qryBuscaFrotaIMAGEM).SaveToFile('C:\BRAIRLINES\PICTURE.JPG');
Image1.Picture.LoadFromFile('C:\BRAIRLINES\PICTURE.JPG');
end
else
begin
// Limpa a imagem
Image1.Picture := nil;
end;
// Verifica se o registro está ativo
if dtmPrincipal.qryBuscaFrotaATIVO.AsString = 'ATIVO' then
begin
checkDesativar.Checked := false;
end
else
begin
checkDesativar.Checked := True;
end;
end;
end.
|
library terminal;
{ Библиотека представляет из себя эмулятор терминала.
Умеет воспринимать нажатые клавиши и отображать их на экране. }
uses Font8x8, GraphABC, System, Timers;
const
/// Предельная позиция знакоместа в x
х_лит_предел = 40;
/// Предельная позиция знакоместа в y
у_лит_предел = 30;
/// РАзмер шрифта на экране
шрифт = 8;
/// Масштаб экрана
масштаб = 2;
окно_высота = шрифт * у_лит_предел * масштаб;
окно_ширина = шрифт * х_лит_предел * масштаб + 8;
фон = clBlack;
перо = clWhite;
type
тНажатие = procedure(лит: char);
тКнопкаВниз = procedure(кнп: integer);
тЭкран = class
private
/// Позиция в литерах по х
_х_лит: integer = 0;
/// Позиция в литерах по y
_у_лит: integer = 0;
/// Состояние курсора
_курс_показ: boolean = false;
/// Признак скроллирования экрана
_скроллинг: boolean = false;
/// Таймер для курсора
_таймер_курсор: Timer;
/// Массив всех символов на экране
_текст: string = '';
/// Текущая литера
_лит: тМасЛит;
/// Печать выбранного байта
procedure _Байт_Печать(байт: byte);
/// Печать выбранной литеры
procedure _Лит_Печать;
/// Выбор русской малой литеры
procedure _РусМал_Выбор(лит: char);
/// Выбор русской большой литеры
procedure _РусБол_Выбор(лит: char);
/// Выбор английской малой буквы
procedure _АнгМал_Выбор(лит: char);
/// Выбор английской болшой буквы
procedure _АнгБол_Выбор(лит: char);
/// Выбор цифры
procedure _Цифра_Выбор(лит: char);
/// Специальные литеры цифры
procedure _Спец_Выбор(лит: char);
/// Выбор литеры из списка
procedure _Лит_Выбор(лит: string);
/// Таймер мерцания курсора
procedure _Курсор_Мерцать;
/// Добавление новой литеры в массив литер
procedure _Текст_Добавить(лит: string);
/// Скроллирует экран, если у_поз вышел за пределы
function _Скролл(): boolean;
public
/// Позиция точки по Х
x_pos: integer = 0;
/// Позиция точки по Y
y_pos: integer = 0;
/// Набор всех литер
лит: тЛитера;
constructor Create(прцНажатие: тНажатие; прцКнпВниз: тКнопкаВниз);
/// Процедура обработки нажатий на клавиши
procedure Клик(лит: string);
end;
constructor тЭкран.Create(прцНажатие: тНажатие; прцКнпВниз: тКнопкаВниз);
begin
Window.Title := 'Test terminal';
Window.Height := окно_высота;
Window.Width := окно_ширина;
Window.Clear(фон);
// Буквы мелкие,подправим масштаб
Coordinate.SetScale(масштаб);
//Установим цвет пера
Pen.Color := перо;
// Запрещаем произвольную перерисовку
LockDrawing;
// Регистрируем обработчик нажатий клавиатуры
OnKeyPress := прцНажатие;
OnKeyDown := прцКнпВниз;
self.лит := new тЛитера;
// Назначаем мигалку курсору
_таймер_курсор := new Timer(330, self._Курсор_Мерцать);
_таймер_курсор.Start;
end;
procedure тЭкран.Клик(лит: string);
{$omp critical section}
begin
//Writeln('Клик! ' + лит);
// Останавливаем таймер курсора
self._таймер_курсор.Stop;
// Добавляем литеру в текст
self._Текст_Добавить(лит);
if not self._Скролл then
begin
// Выбрать литеру
self._Лит_Выбор(лит);
// Теперь напечатать литеру
if self._лит[0] <> 255 then
self._Лит_Печать;
end;
// Запускаем таймер курсора
self._таймер_курсор.Start;
Window.Title := 'x=' + IntToStr(self._х_лит) + ' y=' + IntToStr(self._у_лит) + ' Длина:' + IntToStr(self._текст.Length) + ' х_пред=' + IntToStr(х_лит_предел);
end;
function тЭкран._Скролл(): boolean;
begin
var рез := false;
if (self._текст.Length > у_лит_предел * х_лит_предел) then
begin
self._текст := self._текст.Remove(1, х_лит_предел);
self.x_pos := 0;
self.y_pos := 0;
self._х_лит := 0;
self._у_лит := 0;
Window.Clear(clBlack);
self._скроллинг := true;
for var i := 1 to self._текст.Length do
begin
self._Лит_Выбор(self._текст[i]);
self._Лит_Печать;
end;
self._скроллинг := false;
Redraw;
рез := true;
end;
Result := рез;
end;
procedure тЭкран._Текст_Добавить(лит: string);
begin
if лит.Length = 1 then
self._текст := self._текст + лит
else//Вот здесь воткнуть специальные многолитерне коды
begin
if лит = 'enter' then
begin
var хвост := self._текст.Length mod х_лит_предел;
var хвост_стр := хвост * ' ';
self._текст := self._текст + хвост_стр;
self._Лит_Выбор(' ');//Перебиваем курсор, добиваем пробелы до конца строки
for var i := 1 to хвост do
self._Лит_Печать;
Redraw;
end;
end
end;
procedure тЭкран._Курсор_Мерцать;
begin
if _курс_показ then
begin
self._лит := self.лит.спец.space;
_курс_показ := false;
end
else
begin
self._лит := self.лит.спец.strike;
_курс_показ := true;
end;
self._Лит_Печать;
self.x_pos -= шрифт;
end;
procedure тЭкран._Лит_Выбор(лит: string);
begin
self._лит[0] := 255;//Не может быть больше 127 -- индикатор присвоения
if лит.Length = 1 then
begin
// Если передана одиночная литера,а не специальный код
var лит1: char = лит[1];
self._РусМал_Выбор(лит1);
if self._лит[0] = 255 then// Выбора не было, если 255
self._РусБол_Выбор(лит1);
if self._лит[0] = 255 then// Выбора не было, если 255
self._АнгМал_Выбор(лит1);
if self._лит[0] = 255 then// Выбора не было, если 255
self._АнгБол_Выбор(лит1);
if self._лит[0] = 255 then// Выбора не было, если 255
self._Цифра_Выбор(лит1);
if self._лит[0] = 255 then// Выбора не было, если 255
self._Спец_Выбор(лит1);
end;
end;
procedure тЭкран._Спец_Выбор(лит: char);
begin
case лит of
' ': self._лит := self.лит.спец.space;
'_': self._лит := self.лит.спец.strike;
'-': self._лит := self.лит.спец.minus;
'+': self._лит := self.лит.спец.plus;
'*': self._лит := self.лит.спец.multi;
',': self._лит := self.лит.спец.comma;
'.': self._лит := self.лит.спец.dot;
'(': self._лит := self.лит.спец.lrb;
')': self._лит := self.лит.спец.rrb;
'[': self._лит := self.лит.спец.lsb;
']': self._лит := self.лит.спец.rsb;
'"': self._лит := self.лит.спец.dqt;
'''': self._лит := self.лит.спец.sqt;
'`': self._лит := self.лит.спец.apo;
'~': self._лит := self.лит.спец.tilda;
'!': self._лит := self.лит.спец.akk;
'№': self._лит := self.лит.спец.numer;
'#': self._лит := self.лит.спец.bang;
'$': self._лит := self.лит.спец.dol;
';': self._лит := self.лит.спец.cdot;
'%': self._лит := self.лит.спец.percent;
':': self._лит := self.лит.спец.ddot;
'&': self._лит := self.лит.спец.amp;
'?': self._лит := self.лит.спец.qst;
'=': self._лит := self.лит.спец.equ;
'/': self._лит := self.лит.спец.slh;
'\': self._лит := self.лит.спец.bslh;
'<': self._лит := self.лит.спец.lequ;
'>': self._лит := self.лит.спец.requ;
'^': self._лит := self.лит.спец.exp;
'{': self._лит := self.лит.спец.lfb;
'}': self._лит := self.лит.спец.rfb;
'@': self._лит := self.лит.спец.hun;
'|': self._лит := self.лит.спец.vert;
end;
end;
procedure тЭкран._Цифра_Выбор(лит: char);
begin
case лит of
'0': self._лит := self.лит.циф.d0;
'1': self._лит := self.лит.циф.d1;
'2': self._лит := self.лит.циф.d2;
'3': self._лит := self.лит.циф.d3;
'4': self._лит := self.лит.циф.d4;
'5': self._лит := self.лит.циф.d5;
'6': self._лит := self.лит.циф.d6;
'7': self._лит := self.лит.циф.d7;
'8': self._лит := self.лит.циф.d8;
'9': self._лит := self.лит.циф.d9;
end;
end;
procedure тЭкран._АнгБол_Выбор(лит: char);
begin
case лит of
'A': self._лит := self.лит.анг.bA;
'B': self._лит := self.лит.анг.bB;
'C': self._лит := self.лит.анг.bC;
'D': self._лит := self.лит.анг.bD;
'E': self._лит := self.лит.анг.bE;
'F': self._лит := self.лит.анг.bF;
'G': self._лит := self.лит.анг.bG;
'H': self._лит := self.лит.анг.bH;
'I': self._лит := self.лит.анг.bI;
'J': self._лит := self.лит.анг.bJ;
'K': self._лит := self.лит.анг.bK;
'L': self._лит := self.лит.анг.bL;
'M': self._лит := self.лит.анг.bM;
'N': self._лит := self.лит.анг.bN;
'O': self._лит := self.лит.анг.bO;
'P': self._лит := self.лит.анг.bP;
'Q': self._лит := self.лит.анг.bQ;
'R': self._лит := self.лит.анг.bR;
'S': self._лит := self.лит.анг.bS;
'T': self._лит := self.лит.анг.bT;
'U': self._лит := self.лит.анг.bU;
'V': self._лит := self.лит.анг.bV;
'W': self._лит := self.лит.анг.bW;
'X': self._лит := self.лит.анг.bX;
'Y': self._лит := self.лит.анг.bY;
'Z': self._лит := self.лит.анг.bZ;
end;
end;
procedure тЭкран._АнгМал_Выбор(лит: char);
begin
case лит of
'a': self._лит := self.лит.анг.sA;
'b': self._лит := self.лит.анг.sB;
'c': self._лит := self.лит.анг.sC;
'd': self._лит := self.лит.анг.sD;
'e': self._лит := self.лит.анг.sE;
'f': self._лит := self.лит.анг.sF;
'g': self._лит := self.лит.анг.sG;
'h': self._лит := self.лит.анг.sH;
'i': self._лит := self.лит.анг.sI;
'j': self._лит := self.лит.анг.sJ;
'k': self._лит := self.лит.анг.sK;
'l': self._лит := self.лит.анг.sL;
'm': self._лит := self.лит.анг.sM;
'n': self._лит := self.лит.анг.sN;
'o': self._лит := self.лит.анг.sO;
'p': self._лит := self.лит.анг.sP;
'q': self._лит := self.лит.анг.sQ;
'r': self._лит := self.лит.анг.sR;
's': self._лит := self.лит.анг.sS;
't': self._лит := self.лит.анг.sT;
'u': self._лит := self.лит.анг.sU;
'v': self._лит := self.лит.анг.sV;
'w': self._лит := self.лит.анг.sW;
'x': self._лит := self.лит.анг.sX;
'y': self._лит := self.лит.анг.sY;
'z': self._лит := self.лит.анг.sZ;
end;
end;
procedure тЭкран._РусБол_Выбор(лит: char);
begin
case лит of
'А': self._лит := self.лит.рус.bA;
'Б': self._лит := self.лит.рус.bB;
'В': self._лит := self.лит.рус.bW;
'Г': self._лит := self.лит.рус.bG;
'Д': self._лит := self.лит.рус.bD;
'Е': self._лит := self.лит.рус.bE;
'Ё': self._лит := self.лит.рус.bE2;
'Ж': self._лит := self.лит.рус.bZh;
'З': self._лит := self.лит.рус.bZ;
'И': self._лит := self.лит.рус.bI;
'Й': self._лит := self.лит.рус.bI2;
'К': self._лит := self.лит.рус.bK;
'Л': self._лит := self.лит.рус.bL;
'М': self._лит := self.лит.рус.bM;
'Н': self._лит := self.лит.рус.bN;
'О': self._лит := self.лит.рус.bO;
'П': self._лит := self.лит.рус.bP;
'Р': self._лит := self.лит.рус.bR;
'С': self._лит := self.лит.рус.bS;
'Т': self._лит := self.лит.рус.bT;
'У': self._лит := self.лит.рус.bU;
'Ф': self._лит := self.лит.рус.bF;
'Х': self._лит := self.лит.рус.bKh;
'Ц': self._лит := self.лит.рус.bTc;
'Ч': self._лит := self.лит.рус.bCh;
'Ш': self._лит := self.лит.рус.bSh;
'Щ': self._лит := self.лит.рус.bShh;
'Ъ': self._лит := self.лит.рус.bHz;
'Ы': self._лит := self.лит.рус.bY;
'Ь': self._лит := self.лит.рус.bSz;
'Э': self._лит := self.лит.рус.bEh;
'Ю': self._лит := self.лит.рус.bYu;
'Я': self._лит := self.лит.рус.bJa ;
end;
end;
procedure тЭкран._РусМал_Выбор(лит: char);
begin
case лит of
'а': self._лит := self.лит.рус.sA;
'б': self._лит := self.лит.рус.sB;
'в': self._лит := self.лит.рус.sW;
'г': self._лит := self.лит.рус.sG;
'д': self._лит := self.лит.рус.sD;
'е': self._лит := self.лит.рус.sE;
'ё': self._лит := self.лит.рус.sE2;
'ж': self._лит := self.лит.рус.sZh;
'з': self._лит := self.лит.рус.sZ;
'и': self._лит := self.лит.рус.sI;
'й': self._лит := self.лит.рус.sI2;
'к': self._лит := self.лит.рус.sK;
'л': self._лит := self.лит.рус.sL;
'м': self._лит := self.лит.рус.sM;
'н': self._лит := self.лит.рус.sN;
'о': self._лит := self.лит.рус.sO;
'п': self._лит := self.лит.рус.sP;
'р': self._лит := self.лит.рус.sR;
'с': self._лит := self.лит.рус.sS;
'т': self._лит := self.лит.рус.sT;
'у': self._лит := self.лит.рус.sU;
'ф': self._лит := self.лит.рус.sF;
'х': self._лит := self.лит.рус.sKh;
'ц': self._лит := self.лит.рус.sTc;
'ч': self._лит := self.лит.рус.sCh;
'ш': self._лит := self.лит.рус.sSh;
'щ': self._лит := self.лит.рус.sShh;
'ъ': self._лит := self.лит.рус.sHz;
'ы': self._лит := self.лит.рус.sY;
'ь': self._лит := self.лит.рус.sSz;
'э': self._лит := self.лит.рус.sEh;
'ю': self._лит := self.лит.рус.sYu;
'я': self._лит := self.лит.рус.sJa ;
end;
end;
procedure тЭкран._Лит_Печать;
begin
// цикл по массиву байтов
var байт := 0;
for var y := 0 to 7 do
begin
байт := self._лит[y];
// Отправляем байт на печать
self._Байт_Печать(байт);
self.y_pos += 1;
end;
self.x_pos += шрифт;
if self.x_pos = (окно_ширина div масштаб) then
begin
self.x_pos := 0;
self.y_pos += 1;
end
else
self.y_pos -= 8;
// скроллинг снимается в вызывающей процедуре
if not self._скроллинг then
Redraw;
self._х_лит := self.x_pos div шрифт;
self._у_лит := self.y_pos div шрифт;
end;
procedure тЭкран._Байт_Печать(байт: byte);
begin
// 1. Печатаем точки побитно
var bit := 0;
bit := байт and 128;
if bit = 128 then
SetPixel(self.x_pos + 0, self.y_pos, перо)
else
SetPixel(self.x_pos + 0, self.y_pos, фон);
bit := байт and 64;
if bit = 64 then
SetPixel(self.x_pos + 1, self.y_pos, перо)
else
SetPixel(self.x_pos + 1, self.y_pos, фон);
bit := байт and 32;
if bit = 32 then
SetPixel(self.x_pos + 2, self.y_pos, перо)
else
SetPixel(self.x_pos + 2, self.y_pos, фон);
bit := байт and 16;
if bit = 16 then
SetPixel(self.x_pos + 3, self.y_pos, перо)
else
SetPixel(self.x_pos + 3, self.y_pos, фон);
bit := байт and 8;
if bit = 8 then
SetPixel(self.x_pos + 4, self.y_pos, перо)
else
SetPixel(self.x_pos + 4, self.y_pos, фон);
bit := байт and 4;
if bit = 4 then
SetPixel(self.x_pos + 5, self.y_pos, перо)
else
SetPixel(self.x_pos + 5, self.y_pos, фон);
bit := байт and 2;
if bit = 2 then
SetPixel(self.x_pos + 6, self.y_pos, перо)
else
SetPixel(self.x_pos + 6, self.y_pos, фон);
bit := байт and 1;
if bit = 1 then
SetPixel(self.x_pos + 7, self.y_pos, перо)
else
SetPixel(self.x_pos + 7, self.y_pos, фон);
{var маска := 128;
for var x := 1 to 8 do
begin
маска := маска div 2;
bit := байт and маска;
if bit = маска then
SetPixel(self.x_pos + x, self.y_pos, перо)
else
SetPixel(self.x_pos + x, self.y_pos, фон);
end;}
end;
begin
end. |
unit URepositorioLote;
interface
uses
Ulote
,UEmpresaMatriz
,URepositorioEmpresaMatriz
,UEntidade
,URepositorioDB
,SqlExpr
;
type
TRepositorioLote = class (TRepositorioDB<TLOTE>)
private
FRepositorioEmpresa : TRepositorioEmpresa;
public
constructor create;
destructor destroy; override;
procedure AtribuiDBParaEntidade (const coLote : TLOTE); override;
procedure AtribuiEntidadeParaDB (const coLote : TLOTE;
const coSQLQuery : TSQLQuery); override;
end;
implementation
uses
UDM
,SysUtils
;
{ TRepositorioLote }
procedure TRepositorioLote.AtribuiDBParaEntidade(const coLote: TLOTE);
begin
inherited;
with FSQLSelect do
begin
coLote.LOTE := FieldByName(FLD_LOTE_CODIGO).AsString;
coLote.VALIDADE := FieldByName(FLD_LOTE_VALIDADE).AsDateTime;
coLote.EMPRESA := TEmpresa (
FRepositorioEmpresa.Retorna(FieldByName(FLD_LOTE_EMPRESA).AsInteger));
end;
end;
procedure TRepositorioLote.AtribuiEntidadeParaDB(const coLote: TLOTE;
const coSQLQuery: TSQLQuery);
begin
inherited;
with coSQLQuery do
begin
ParamByName (FLD_LOTE_CODIGO).AsString := coLote.LOTE;
ParamByName (FLD_LOTE_VALIDADE).AsDateTime := coLote.VALIDADE;
ParamByName (FLD_LOTE_EMPRESA).AsInteger := coLote.EMPRESA.ID;
end;
end;
constructor TRepositorioLote.create;
begin
inherited Create (TLOTE, TBL_LOTE, FLD_ENTIDADE_ID, STR_LOTE);
FrepositorioEmpresa := TRepositorioEmpresa.Create;
end;
destructor TRepositorioLote.destroy;
begin
FreeAndNil(FRepositorioEmpresa);
inherited;
end;
end.
|
{
DelphiProtocolBuffer ProtBuf.pas
declares the TProtocolBufferMessage base class
used by units generated by dpbp
Copyright 2014-2016 Stijn Sanders
Made available under terms described in file "LICENSE"
https://github.com/stijnsanders/DelphiProtocolBuffer
}
unit ProtBuf;
{$D-}
{$L-}
interface
uses Classes;
type
TProtocolBufferKey = 0..$1FFFFFFF;//cardinal, uint23
TDynArrayOfBytes = array of byte;
TProtocolBufferMessage=class(TObject)//,IStreamPersist)
private
FDidRead:boolean;
protected
procedure SetDefaultValues; virtual;
procedure ReadVarInt(Stream: TStream; Key: TProtocolBufferKey); virtual;
procedure ReadLengthDelim(Stream: TStream; Key: TProtocolBufferKey); virtual;
procedure ReadFixed64(Stream: TStream; Key: TProtocolBufferKey); virtual;
procedure ReadFixed32(Stream: TStream; Key: TProtocolBufferKey); virtual;
procedure WriteFields(Stream: TStream); virtual;
//use from LoadFromStream
procedure ReadUint(Stream: TStream; var Value: cardinal); overload;
procedure ReadUint(Stream: TStream; var Value: int64); overload;
procedure ReadSint(Stream: TStream; var Value: integer); overload;
procedure ReadSint(Stream: TStream; var Value: int64); overload;
procedure ReadStr(Stream: TStream; var Value: string);
procedure ReadBytes(Stream: TStream; var Value: TDynArrayOfBytes);
function ReadBool(Stream: TStream): boolean;
function ReadEnum(Stream: TStream): cardinal;
procedure ReadMessage(Stream: TStream; Value: TProtocolBufferMessage);
procedure ReadBlock(Stream: TSTream; var Data; Length: cardinal);
//use from ReadValue
procedure WriteSInt(Stream: TStream; Key: TProtocolBufferKey;
Value: integer);
procedure WriteUInt(Stream: TStream; Key: TProtocolBufferKey;
Value: cardinal);
procedure WriteSInt64(Stream: TStream; Key: TProtocolBufferKey;
Value: int64);
procedure WriteUInt64(Stream: TStream; Key: TProtocolBufferKey;
Value: int64);
procedure WriteSingle(Stream: TStream; Key: TProtocolBufferKey;
Value: Single);
procedure WriteDouble(Stream: TStream; Key: TProtocolBufferKey;
Value: Double);
procedure WriteStr(Stream: TStream; Key: TProtocolBufferKey;
const Value: UTF8String); overload;
procedure WriteStrA(Stream: TStream; Key: TProtocolBufferKey;
const Value: AnsiString);
procedure WriteStr(Stream: TStream; Key: TProtocolBufferKey;
const Value: WideString); overload;
procedure WriteMessage(Stream: TStream; Key: TProtocolBufferKey;
Value: TProtocolBufferMessage);
procedure WriteBlock(Stream: TStream; Key: TProtocolBufferKey;
var Data; Length: cardinal);
public
constructor Create;
procedure LoadFromStream(Stream: TStream; Length: int64);
procedure SaveToStream(Stream: TStream);
end;
implementation
uses SysUtils, Variants;
{ TProtocolBufferMessage }
constructor TProtocolBufferMessage.Create;
begin
inherited;
SetDefaultValues;
//
end;
procedure _ReadError; //virtual? keep Stream reference?
begin
raise Exception.Create('Error reading from stream');
end;
function _ReadVarInt(Stream: TStream; var Value: cardinal): boolean; overload;
var
b:byte;
i,l:integer;
begin
b:=0;//default
i:=0;
l:=Stream.Read(b,1);
Value:=b and $7F;
while (l<>0) and ((b and $80)<>0) do
begin
l:=Stream.Read(b,1);
inc(i,7);
Value:=Value or ((b and $7F) shl i);
end;
Result:=l<>0;
end;
function _ReadVarInt(Stream: TStream; var Value: int64): boolean; overload;
var
b:byte;
i,l:integer;
begin
b:=0;//default
i:=0;
l:=Stream.Read(b,1);
Value:=b and $7F;
while (l<>0) and ((b and $80)<>0) do
begin
l:=Stream.Read(b,1);
inc(i,7);
Value:=Value or ((b and $7F) shl i);
end;
Result:=l<>0;
end;
procedure _WriteError; //virtual? keep Stream reference?
begin
raise Exception.Create('Error writing to stream');
end;
procedure _WriteVarInt(Stream: TStream; x: cardinal); overload;
var
i:cardinal;
b:byte;
begin
i:=0;
repeat inc(i,7) until (1 shl i)>=x;
while i<>0 do
begin
dec(i,7);
b:=(x shr i) and $7F;
if Stream.Write(b,1)<>1 then _WriteError;
end;
end;
procedure _WriteVarInt(Stream: TStream; x: int64); overload;
var
i:int64;
b:byte;
begin
i:=0;
repeat inc(i,7) until (1 shl i)>=x;
while i<>0 do
begin
dec(i,7);
b:=(x shr i) and $7F;
if Stream.Write(b,1)<>1 then _WriteError;
end;
end;
procedure TProtocolBufferMessage.LoadFromStream(Stream: TStream;
Length: int64);
var
i:cardinal;
k:TProtocolBufferKey;
j,p:int64;
begin
//TODO: use some byte buffer
if Length=0 then
p:=Stream.Size //raise? detect?
else
p:=Stream.Position+Length;
//TODO: increase counter on (all!) reads instead of Stream.Position here
while (Stream.Position<p) and _ReadVarInt(Stream,i) do
begin
k:=TProtocolBufferKey(i shr 3);
FDidRead:=false;//see read methods
case i and $7 of
0://varint
begin
ReadVarInt(Stream,k);
if not FDidRead then if not _ReadVarInt(Stream,j) then _ReadError;
end;
1://fixed64
begin
ReadFixed64(Stream,k);
if not FDidRead then if Stream.Read(j,8)<>8 then _ReadError;
end;
2://length delimited
begin
ReadLengthDelim(Stream,k);
if not FDidRead then
begin
if not _ReadVarInt(Stream,j) then _ReadError;
Stream.Seek(j,soFromCurrent);
end;
end;
3,4:raise Exception.Create('ProtBuf: groups are deprecated');
5://fixed32
begin
ReadFixed32(Stream,k);
if not FDidRead then if Stream.Read(j,4)<>4 then _ReadError;
end;
else
raise Exception.Create('ProfBuf: unexpected wire type '+IntToHex(i,8));
end;
end;
end;
procedure TProtocolBufferMessage.SaveToStream(Stream: TStream);
begin
WriteFields(Stream);
end;
procedure TProtocolBufferMessage.SetDefaultValues;
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.ReadFixed32(Stream: TStream;
Key: TProtocolBufferKey);
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.ReadFixed64(Stream: TStream;
Key: TProtocolBufferKey);
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.ReadLengthDelim(Stream: TStream;
Key: TProtocolBufferKey);
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.ReadVarInt(Stream: TStream;
Key: TProtocolBufferKey);
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.WriteFields(Stream: TStream);
begin
//implemented by inheriters
end;
procedure TProtocolBufferMessage.WriteSInt(Stream: TStream;
Key: TProtocolBufferKey; Value: integer);
begin
_WriteVarInt(Stream,Key shl 3);//Key, 0
if Value<0 then
_WriteVarInt(Stream,cardinal(Value*-2-1))
else
_WriteVarInt(Stream,cardinal(Value*2));
end;
procedure TProtocolBufferMessage.WriteSInt64(Stream: TStream;
Key: TProtocolBufferKey; Value: int64);
begin
_WriteVarInt(Stream,Key shl 3);//Key, 0
if Value<0 then
_WriteVarInt(Stream,Value*-2-1)
else
_WriteVarInt(Stream,Value*2);
end;
procedure TProtocolBufferMessage.WriteUInt(Stream: TStream;
Key: TProtocolBufferKey; Value: cardinal);
begin
_WriteVarInt(Stream,Key shl 3);//Key, 0
_WriteVarInt(Stream,Value);
end;
procedure TProtocolBufferMessage.WriteUInt64(Stream: TStream;
Key: TProtocolBufferKey; Value: int64);
begin
_WriteVarInt(Stream,Key shl 3);//Key, 0
_WriteVarInt(Stream,Value);
end;
procedure TProtocolBufferMessage.WriteSingle(Stream: TStream;
Key: TProtocolBufferKey; Value: Single);
begin
_WriteVarInt(Stream,(Key shl 3) or 5);
if Stream.Write(Value,4)<>4 then _WriteError;
end;
procedure TProtocolBufferMessage.WriteDouble(Stream: TStream;
Key: TProtocolBufferKey; Value: Double);
begin
_WriteVarInt(Stream,(Key shl 3) or 1);
if Stream.Write(Value,8)<>8 then _WriteError;
end;
procedure TProtocolBufferMessage.WriteStr(Stream: TStream;
Key: TProtocolBufferKey; const Value: UTF8String);
var
l:cardinal;
begin
l:=Length(Value);
_WriteVarInt(Stream,(Key shl 3) or 2);
_WriteVarInt(Stream,l);
if l<>0 then
if cardinal(Stream.Write(Value[1],l))<>l then _WriteError;
end;
procedure TProtocolBufferMessage.WriteStr(Stream: TStream;
Key: TProtocolBufferKey; const Value: WideString);
var
x:UTF8String;
l:cardinal;
begin
x:=UTF8Encode(Value);
l:=Length(x);
_WriteVarInt(Stream,(Key shl 3) or 2);
_WriteVarInt(Stream,l);
if l<>0 then
if cardinal(Stream.Write(x[1],l))<>l then _WriteError;
end;
procedure TProtocolBufferMessage.WriteStrA(Stream: TStream;
Key: TProtocolBufferKey; const Value: AnsiString);
var
x:UTF8String;
l:cardinal;
begin
x:=AnsiToUtf8(Value);
l:=Length(x);
_WriteVarInt(Stream,(Key shl 3) or 2);
_WriteVarInt(Stream,l);
if l<>0 then
if cardinal(Stream.Write(x[1],l))<>l then _WriteError;
end;
procedure TProtocolBufferMessage.WriteMessage(Stream: TStream;
Key: TProtocolBufferKey; Value: TProtocolBufferMessage);
var
m:TMemoryStream;
l:cardinal;
begin
_WriteVarInt(Stream,(Key shl 3) or 2);
//TODO: find another way to write data first and a variable length prefix after
m:=TMemoryStream.Create;
try
Value.SaveToStream(m);
l:=m.Position;
_WriteVarInt(Stream,l);
m.Position:=0;
if l<>0 then
if cardinal(Stream.Write(m.Memory^,l))<>l then _WriteError;
finally
m.Free;
end;
end;
procedure TProtocolBufferMessage.WriteBlock(Stream: TStream;
Key: TProtocolBufferKey; var Data; Length: cardinal);
begin
_WriteVarInt(Stream,(Key shl 3) or 2);
if Length<>0 then
if cardinal(Stream.Write(Data,Length))<>Length then _WriteError;
end;
procedure TProtocolBufferMessage.ReadBytes(Stream: TStream;
var Value: TDynArrayOfBytes);
var
l:cardinal;//int64?
begin
if not _ReadVarInt(Stream,l) then _ReadError;
SetLength(Value,l);
if l<>0 then
if cardinal(Stream.Read(Value[0],l))<>l then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadStr(Stream: TStream; var Value: string);
var
l:cardinal;//int64?
begin
if not _ReadVarInt(Stream,l) then _ReadError;
SetLength(Value,l);
if l<>0 then
if cardinal(Stream.Read(Value[1],l))<>l then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadUint(Stream: TStream;
var Value: cardinal);
begin
if not _ReadVarInt(Stream,Value) then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadUint(Stream: TStream;
var Value: int64);
begin
if not _ReadVarInt(Stream,Value) then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadSint(Stream: TStream;
var Value: int64);
begin
if not _ReadVarInt(Stream,Value) then _ReadError;
if (Value and 1)=0 then
Value:=Value shr 1
else
Value:=-((Value+1) shr 1);
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadSint(Stream: TStream;
var Value: integer);
begin
if not _ReadVarInt(Stream,cardinal(Value)) then _ReadError;
if (Value and 1)=0 then
Value:=Value shr 1
else
Value:=-((Value+1) shr 1);
FDidRead:=true;
end;
function TProtocolBufferMessage.ReadBool(Stream: TStream): boolean;
var
i:cardinal;
begin
if not _ReadVarInt(Stream,i) then _ReadError;
FDidRead:=true;
Result:=i<>0;
end;
function TProtocolBufferMessage.ReadEnum(Stream: TStream): cardinal;
begin
if not _ReadVarInt(Stream,Result) then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadMessage(Stream: TStream;
Value: TProtocolBufferMessage);
var
l:int64;
begin
if not _ReadVarInt(Stream,l) then _ReadError;
//p:=Stream.Position;
Value.LoadFromStream(Stream,l);
//if Stream.Position<>p+l then _ReadError;
FDidRead:=true;
end;
procedure TProtocolBufferMessage.ReadBlock(Stream: TSTream; var Data;
Length: cardinal);
begin
if Length<>0 then
if cardinal(Stream.Read(Data,Length))<>Length then _ReadError;
FDidRead:=true;
end;
end.
|
unit uPow2StringConverter;
{$I ..\Include\IntXLib.inc}
interface
uses
uIStringConverter,
uConstants,
uXBits,
uIntX,
uIntXLibTypes;
type
/// <summary>
/// Provides special fast (with linear time) ToString converting if base is pow of 2.
/// </summary>
TPow2StringConverter = class sealed(TInterfacedObject, IIStringConverter)
public
/// <summary>
/// Converts digits from internal representaion into given base.
/// </summary>
/// <param name="IntX">Big Integer.</param>
/// <param name="numberBase">Base to use for output.</param>
/// <param name="alphabet">alphabet array to use.</param>
/// <returns>Conversion result.</returns>
function ToString(IntX: TIntX; numberBase: UInt32;
alphabet: TIntXLibCharArray): String; reintroduce; overload;
/// <summary>
/// Converts digits from internal representaion into given base.
/// </summary>
/// <param name="digits">Big integer digits.</param>
/// <param name="mlength">Big integer length.</param>
/// <param name="numberBase">Base to use for output.</param>
/// <param name="outputLength">Calculated output length (will be corrected inside).</param>
/// <returns>Conversion result (later will be transformed to string).</returns>
function ToString(digits: TIntXLibUInt32Array; mlength: UInt32;
numberBase: UInt32; var outputLength: UInt32): TIntXLibUInt32Array;
reintroduce; overload;
end;
implementation
function TPow2StringConverter.ToString(IntX: TIntX; numberBase: UInt32;
alphabet: TIntXLibCharArray): String;
begin
result := '';
Exit;
end;
function TPow2StringConverter.ToString(digits: TIntXLibUInt32Array;
mlength: UInt32; numberBase: UInt32; var outputLength: UInt32)
: TIntXLibUInt32Array;
var
bitsInChar, nextDigitShift, initialShift: Integer;
digitsBitLength: UInt64;
realOutputLength, digitBitMask, outputDigit, outputIndex, digitIndex: UInt32;
outputArray: TIntXLibUInt32Array;
begin
// Calculate real output length
bitsInChar := TBits.Msb(numberBase);
digitsBitLength := UInt64(mlength - 1) * TConstants.DigitBitCount +
UInt64(TBits.Msb(digits[mlength - 1])) + UInt64(1);
realOutputLength := UInt32(digitsBitLength) div UInt64(bitsInChar);
if (digitsBitLength mod UInt64(bitsInChar) <> 0) then
begin
Inc(realOutputLength);
end;
// Prepare shift variables
nextDigitShift := TConstants.DigitBitCount - bitsInChar;
// after this shift next digit must be used
initialShift := 0;
// We will also need bitmask for copying digits
digitBitMask := numberBase - 1;
// Create an output array for storing of number in other base
SetLength(outputArray, realOutputLength);
outputIndex := 0;
digitIndex := 0;
// Walk through original digits and fill output
while outputIndex < (realOutputLength) do
begin
// Get part of current digit
outputDigit := digits[digitIndex] shr initialShift;
// Maybe we need to go to the next digit
if (initialShift >= nextDigitShift) then
begin
// Go to the next digit
Inc(digitIndex);
// Maybe we also need a part of the next digit
if ((initialShift <> nextDigitShift) and (digitIndex < mlength)) then
begin
outputDigit := outputDigit or
(digits[digitIndex] shl (TConstants.DigitBitCount - initialShift));
end;
// Modify shift so that it will be valid for the next digit
initialShift := (initialShift + bitsInChar) mod TConstants.DigitBitCount;
end
else
begin
// Modify shift as usual
initialShift := initialShift + bitsInChar;
end;
// Write masked result to the output
outputArray[outputIndex] := outputDigit and digitBitMask;
Inc(outputIndex);
end;
outputLength := realOutputLength;
result := outputArray;
end;
end.
|
(* Stack ADT 3 19.04.2017 *)
(* ---------- *)
(* implementing the stack as abstract data type - version 3 *)
(* ========================================================= *)
UNIT StackADT3;
INTERFACE
TYPE
Stack = ^StackRec;
StackRec = RECORD
max : INTEGER;
data: ARRAY[1..1] OF INTEGER;
top: INTEGER;
END;
PROCEDURE NewStack(VAR s: Stack; max: INTEGER);
PROCEDURE DisposeStack(VAR s: Stack);
PROCEDURE Push(VAR s: Stack; e: INTEGER);
PROCEDURE Pop(VAR s: Stack; VAR e: INTEGER);
FUNCTION Empty(s: Stack): BOOLEAN;
IMPLEMENTATION
PROCEDURE NewStack(VAR s: Stack; max: INTEGER);
VAR
intSize: INTEGER;
mem: INTEGER;
BEGIN
intSize := SizeOf(INTEGER);
mem := intSize + intSize * max + intSize;
(* Alternative:
2 Byte for max + 2 Byte for each integer in data (size max) + 2 Byte for top *)
(* GetMem(s, 2 + max*2 + 2) *)
GetMem(s, mem);
s^.top := 0;
s^.max := max;
END;
PROCEDURE DisposeStack(VAR s: Stack);
VAR
intSize: INTEGER;
mem: INTEGER;
BEGIN
intSize := SizeOf(INTEGER);
mem := intSize + intSize * s^.max + intSize;
(* Alternative:
2 Byte for max + 2 Byte for each integer in data (size max) + 2 Byte for top *)
(* FreeMem(s, 2 + max*2 + 2) *)
FreeMem(s, mem);
s := NIL;
END;
PROCEDURE Push(VAR s: Stack; e: INTEGER);
BEGIN
IF s^.top = s^.max THEN BEGIN
WriteLn('Stack overflow');
END
ELSE BEGIN
s^.top := s^.top + 1;
{$R-}
s^.data[s^.top] := e;
{$R+}
END;
END;
PROCEDURE Pop(VAR s: Stack; VAR e: INTEGER);
BEGIN
IF s^.top = 0 THEN BEGIN
WriteLn('Stack underflow');
END
ELSE BEGIN
{$R-}
e := s^.data[s^.top];
{$R+}
s^.top := s^.top - 1;
END;
END;
FUNCTION Empty(s: Stack): BOOLEAN;
BEGIN
Empty := s^.top = 0;
END;
BEGIN
END. (* StackADT3 *)
|
unit fmeVolumeSelect;
interface
uses
Classes, Controls, Dialogs, Forms,
Graphics, Messages, OTFEFreeOTFEBase_U, SDUDialogs, SDUFrames, StdCtrls,
SysUtils, Variants, Vcl.Buttons,
Windows;
type
TOpenSave = (fndOpen, fndSave);
TfmeVolumeSelect = class (TSDUFrame)
bbBrowsePartition: TBitBtn;
bbBrowseFile: TBitBtn;
edFilename: TEdit;
OpenDialog: TSDUOpenDialog;
SaveDialog: TSDUSaveDialog;
procedure bbBrowseFileClick(Sender: TObject);
procedure bbBrowsePartitionClick(Sender: TObject);
procedure edFilenameChange(Sender: TObject);
PRIVATE
FFileButtonAdjust: Integer;
FSelectFor: TOpenSave;
FFileSelectFilter: String;
FFileSelectDefaultExt: String;
FOnChange: TNotifyEvent;
FFileGlyph: Vcl.Graphics.TBitmap;
function GetFilename(): String;
procedure SetFilename(filename: String);
function GetAllowPartitionSelect(): Boolean;
procedure SetAllowPartitionSelect(allow: Boolean);
PROTECTED
function GetEnabled(): Boolean; OVERRIDE;
procedure SetEnabled(setValue: Boolean); OVERRIDE;
PUBLIC
// OTFEFreeOTFE: TOTFEFreeOTFEBase;
constructor Create(AOwner: TComponent); OVERRIDE;
destructor Destroy(); OVERRIDE;
PUBLISHED
property OnChange: TNotifyEvent Read FOnChange Write FOnChange;
property Filename: String Read GetFilename Write SetFilename;
property SelectFor: TOpenSave Read FSelectFor Write FSelectFor;
property AllowPartitionSelect: Boolean Read GetAllowPartitionSelect
Write SetAllowPartitionSelect;
property FileSelectFilter: String Read FFileSelectFilter Write FFileSelectFilter;
property FileSelectDefaultExt: String Read FFileSelectDefaultExt Write FFileSelectDefaultExt;
end;
// procedure Register;
implementation
{$R *.dfm}
uses
SDUGeneral;
// procedure Register;
// begin
// RegisterComponents('FreeOTFE', [TfmeVolumeSelect]);
// end;
procedure TfmeVolumeSelect.bbBrowseFileClick(Sender: TObject);
var
dlg: TOpenDialog; // Note: Save dialog inherits from this. Don't use TSDUOpenDialog here
begin
dlg := SaveDialog;
if (SelectFor = fndOpen) then begin
dlg := OpenDialog;
end;
dlg.Filter := FileSelectFilter;
dlg.DefaultExt := FileSelectDefaultExt;
dlg.Options := dlg.Options + [ofDontAddToRecent];
SDUOpenSaveDialogSetup(dlg, edFilename.Text);
if dlg.Execute() then begin
edFilename.Text := dlg.Filename;
end;
end;
procedure TfmeVolumeSelect.bbBrowsePartitionClick(Sender: TObject);
var
selectedPartition: String;
begin
if (GetFreeOTFEBase() <> nil) then begin
selectedPartition := GetFreeOTFEBase().SelectPartition();
if (selectedPartition <> '') then begin
edFilename.Text := selectedPartition;
end;
end;
//
end;
//
constructor TfmeVolumeSelect.Create(AOwner: TComponent);
begin
inherited;
SetFilename('');
self.Height := edFilename.Height;
FFileGlyph := Vcl.Graphics.TBitmap.Create();
FFileGlyph.Assign(bbBrowseFile.Glyph);
// Pre-calculate difference in file browse button position/TEdit width when
// switching enabling/disabling partition select
FFileButtonAdjust := ((bbBrowseFile.Left + bbBrowseFile.Width) -
// Position of righthand edge of browse file button
(edFilename.Left +
edFilename.Width) // Position of righthand edge of filename TEdit
);
end;
destructor TfmeVolumeSelect.Destroy();
begin
FFileGlyph.Free();
inherited;
end;
function TfmeVolumeSelect.GetFilename(): String;
begin
Result := Trim(edFilename.Text);
end;
procedure TfmeVolumeSelect.SetFilename(filename: String);
begin
edFilename.Text := filename;
end;
function TfmeVolumeSelect.GetAllowPartitionSelect(): Boolean;
begin
Result := bbBrowsePartition.Enabled;
end;
procedure TfmeVolumeSelect.SetAllowPartitionSelect(allow: Boolean);
begin
if (bbBrowsePartition.Visible <> allow) then begin
// Eliminate/allow partition button, remove/restore image from remaining
// button; replace with "..." text if needed
bbBrowsePartition.Visible := allow;
if allow then begin
bbBrowseFile.Caption := '';
bbBrowseFile.Glyph := FFileGlyph;
bbBrowseFile.Left := bbBrowseFile.Left - FFileButtonAdjust;
edFilename.Width := edFilename.Width - FFileButtonAdjust;
end else begin
bbBrowseFile.Caption := '...';
bbBrowseFile.Glyph := nil;
bbBrowseFile.Left := bbBrowseFile.Left + FFileButtonAdjust;
edFilename.Width := edFilename.Width + FFileButtonAdjust;
end;
end;
end;
//
procedure TfmeVolumeSelect.edFilenameChange(Sender: TObject);
begin
if Assigned(fOnChange) then begin
fOnChange(self);
end;
//
end;
//
function TfmeVolumeSelect.GetEnabled(): Boolean;
begin
Result := inherited GetEnabled();
end;
procedure TfmeVolumeSelect.SetEnabled(setValue: Boolean);
begin
SDUEnableControl(edFilename, setValue);
inherited;
SDUEnableControl(bbBrowseFile, setValue);
SDUEnableControl(bbBrowsePartition, setValue);
end;
end.
|
unit u_parser;
{$mode objfpc}{$H+}
interface
uses
Classes,
SysUtils,
u_tokens;
const
AlphaChars: set of char = ['a'..'z', '_'];
DigitChars: set of char = ['0'..'9'];
HexChars: set of char = ['0'..'9', 'a'..'f'];
type
TMashParser = class
public
fp: string;
code: TStringList;
tokens: TList;
line: Cardinal;
commentGoing: boolean;
constructor Create(_code: TStringList; _fp: string);
destructor Destroy;
procedure Parse;
private
procedure ParseLine(s: string);
procedure Preprocess;
end;
implementation
constructor TMashParser.Create(_code: TStringList; _fp: string);
begin
self.code := _code;
self.fp := _fp;
self.line := 0;
self.commentGoing := false;
self.tokens := TList.Create;
end;
destructor TMashParser.Destroy;
begin
FreeAndNil(self.tokens);
end;
procedure TMashParser.Parse;
var
s: string;
tk: TMashToken;
begin
while self.code.count > self.line do
begin
s := trim(code[self.line]);
if Length(s) > 0 then
begin
self.ParseLine(s);
if self.tokens.count > 0 then
begin
tk := TMashToken(self.tokens[self.tokens.count - 1]);
if tk.info <> ttEndOfLine then
self.tokens.add(
TMashToken.Create('', ttEndOfLine, self.line, self.fp)
);
end;
end;
inc(self.line);
end;
self.Preprocess;
end;
procedure TMashParser.Preprocess;
var
i: Cardinal;
tk, tkL, tkR: TMashToken;
begin
i := 1;
while i < (self.tokens.count - 1) do
begin
tk := TMashToken(self.tokens[i]);
if tk.info = ttEndOfLine then
begin
tkL := TMashToken(self.tokens[i - 1]);
tkR := TMashToken(self.tokens[i + 1]);
if (tkR.info = ttEndOfLine) or
(tkR.short in MashOperatorsTokens) or
(tkL.short in MashOperatorsTokens) or
(tkR.short in [tkComma, tkCBr, tkCRBr, tkByPtr]) or
(tkL.short in [tkComma, tkOBr, tkORBr, tkByPtr]) then
begin
self.tokens.Delete(i);
i := 0;
end;
end;
inc(i);
end;
end;
function IsToken(s: string): boolean;
var
i: TMashTokenID;
begin
Result := false;
for i := tkProc to tkReturn do
if s = MashTokens[i] then
begin
Result := true;
break;
end;
end;
procedure TMashParser.ParseLine(s: string);
var
st: string;
line_ended: boolean;
ch: char;
// For token/word
wrd: string;
tt: TMashTokenType;
// For digit/float/hex
dig: string;
dot: boolean;
// Operator search
t, op, ts: string;
founded, brk: boolean;
spaces: word;
tk: TMashTokenID;
begin
while Length(s) > 0 do
begin
if (copy(s, 1, 2) = '//') and (not self.commentGoing) then
break;
if copy(s, 1, 2) = '/*' then
begin
self.commentGoing := true;
Delete(s, 1, 2);
end;
while (copy(s, 1, 1) = '"') and (not self.commentGoing) do
begin
Delete(s, 1, 1);
line_ended := false;
st := '';
while Length(s) > 0 do
begin
if s[1] = '"' then
begin
line_ended := true;
Delete(s, 1, 1);
break;
end
else
begin
st := st + s[1];
Delete(s, 1, 1);
end;
end;
self.tokens.add(
TMashToken.Create(st, ttString, self.line, self.fp)
);
if not line_ended then
raise Exception.Create(
'Missed string end ''"'' symbol at line ' +
IntToStr(self.line + 1) + ' at file ''' + self.fp + '''.'
);
s := trim(s);
end;
if not self.commentGoing then
begin
s := trim(s);
if Length(s) > 0 then
begin
// Searching for word or token
if LowerCase(s[1]) in AlphaChars then
begin
wrd := '';
while Length(s) > 0 do
begin
ch := LowerCase(s[1]);
if (ch in AlphaChars) or (ch in DigitChars) then
begin
wrd += ch;
Delete(s, 1, 1);
end
else
break;
end;
if wrd = 'init' then
begin
self.tokens.add(
TMashToken.Create('proc', ttToken, self.line, self.fp)
);
self.tokens.add(
TMashToken.Create('create', ttWord, self.line, self.fp)
);
end
else
begin
if IsToken(wrd) then
tt := ttToken
else
tt := ttWord;
self.tokens.add(
TMashToken.Create(wrd, tt, self.line, self.fp)
);
end;
end
else
begin
// Searching for digit|float|hex
if s[1] in DigitChars then
begin
dig := '';
dot := false;
if copy(s, 1, 2) = '0x' then
begin
dig := '$';
Delete(s, 1, 2);
while (Length(s) > 0) and
(LowerCase(copy(s, 1, 1))[1] in HexChars) do
begin
dig += LowerCase(s[1]);
Delete(s, 1, 1);
end;
end
else
begin
while Length(s) > 0 do
begin
if s[1] in DigitChars then
begin
dig += s[1];
Delete(s, 1, 1);
end
else
begin
if (s[1] = '.') and
(not dot) and
(copy(s, 2, 1)[1] in DigitChars) then
begin
dig += s[1];
Delete(s, 1, 1);
dot := true;
end
else
break;
end;
end;
end;
if Length(dig) = 0 then
raise Exception.Create(
'Invalid token (digit?) at line ' +
IntToStr(self.line + 1) + ' at file ''' + self.fp + '''.'
);
self.tokens.add(
TMashToken.Create(dig, ttDigit, self.line, self.fp)
);
end
// Searching for operator
else
begin
t := '';
op := '';
founded := false;
brk := false;
spaces := 0;
ts := s;
while (Length(ts) > 0) and (not brk) do
begin
if ts[1] <> ' ' then
t += ts[1]
else
Inc(spaces);
Delete(ts, 1, 1);
if IsToken(t) then
begin
op := t;
founded := true;
end;
brk := true;
for tk := tkProc to tkReturn do
begin
if Pos(t, MashTokens[tk]) > 0 then
begin
brk := false;
break;
end;
end;
end;
Delete(s, 1, Length(op) + spaces);
if op = '$' then
begin
self.tokens.add(
TMashToken.Create('this', ttWord, self.line, self.fp)
);
self.tokens.add(
TMashToken.Create('->', ttToken, self.line, self.fp)
);
end
else
if founded then
self.tokens.add(
TMashToken.Create(op, ttToken, self.line, self.fp)
)
else
raise Exception.Create(
'Unknown operator ''' + op + ''' at line ' +
IntToStr(self.line + 1) + ' at file ''' + self.fp + '''.'
);
end;
end; // strlower(s[0]) in AlphaChars
end; // len(s) > 0
end;
if self.commentGoing then
begin
if copy(s, 1, 2) = '*/' then
begin
self.commentGoing := false;
Delete(s, 1, 2);
end
else
if Length(s) > 0 then
Delete(s, 1, 1);
end;
s := trim(s);
end;
end;
end.
|
unit uW7TaskBar;
interface
uses
Windows, ComObj, ShlObj, ActiveX;
const
CLSID_TaskbarList: TGUID = '{56fdf344-fd6d-11d0-958a-006097c9a090}';
IID_ITaskbarList : TGUID = '{56FDF342-FD6D-11d0-958A-006097C9A090}';
IID_ITaskbarList2: TGUID = '{602D4995-B13A-429b-A66E-1935E44F4317}';
IID_ITaskbarList3: TGUID = '{ea1afb91-9e28-4b86-90e9-9e9f8a5eefaf}';
type
TBPF = (TBPF_NOPROGRESS = 0,
TBPF_INDETERMINATE = 1,
TBPF_NORMAL = 2,
TBPF_ERROR = 4,
TBPF_PAUSED = 8);
TBATF = (TBATF_USEMDITHUMBNAIL = 1,
TBATF_USEMDILIVEPREVIEW = 2);
ITaskbarList = interface(IUnknown)
['{56FDF342-FD6D-11d0-958A-006097C9A090}']
function HrInit: HResult; stdcall;
function AddTab(hWndOwner: HWND): HRESULT; stdcall;
function DeleteTab(hWndOwner: HWND): HRESULT; stdcall;
function ActivateTab(hWndOwner: HWND): HRESULT; stdcall;
function SetActiveAlt(hWndOwner: HWND): HRESULT; stdcall;
end; { ITaskbarList }
ITaskbarList2 = interface(ITaskbarList)
['{602D4995-B13A-429b-A66E-1935E44F4317}']
function MarkFullscreenWindow(wnd : HWND; fFullscreen : bool) : HResult; stdcall;
end;
ITaskbarList3 = interface (ITaskbarList2)
['{ea1afb91-9e28-4b86-90e9-9e9f8a5eefaf}']
function SetProgressValue (hWnd: HWND; ullCompleted: int64; ullTotal: int64): HRESULT; stdcall;
function SetProgressState (hWnd: HWND; tbpFlags: TBPF): HRESULT; stdcall;
function RegisterTab (hwndTab: HWND; hwndMDI: HWND): HRESULT; stdcall;
function UnregisterTab (hwndTab: HWND): HRESULT; stdcall;
function SetTabOrder (hwndTab: HWND; hwndInsertBefore: HWND): HRESULT; stdcall;
function SetTabActive (hwndTab: HWND; hwndMDI: HWND; tbatFlags: TBATF): HRESULT; stdcall;
function ThumbBarAddButtons (hWnd: HWND; cButtons: integer; pButtons: pointer): HRESULT; stdcall;
function ThumbBarUpdateButtons (hWnd: HWND; cButtons: cardinal; pButtons: pointer): HRESULT; stdcall;
function ThumbBarSetImageList (hWnd: HWND; himl: pointer): HRESULT; stdcall;
function SetOverlayIcon (hWnd: HWND; hIcon: HICON; pszDescription: PWideChar): HRESULT; stdcall;
function SetThumbnailTooltip (hWnd: HWND; pszTip: PWideChar): HRESULT; stdcall;
function SetThumbnailClip (hWnd: HWND; prcClip: PRect): HRESULT; stdcall;
end;
function CreateTaskBarInstance : ITaskbarList3;
implementation
function CreateTaskBarInstance : ITaskbarList3;
begin
if CoCreateInstance(CLSID_TaskbarList, nil, CLSCTX_INPROC_SERVER or CLSCTX_LOCAL_SERVER, IID_ITaskbarList3, Result) = S_OK then
if Result.HrInit <> S_OK then
begin
Result._Release;
Result := nil;
end else
Exit;
Result := nil;
end;
end.
|
//
// Generated by JavaToPas v1.5 20171018 - 170649
////////////////////////////////////////////////////////////////////////////////
unit android.provider.Telephony_Mms_Intents;
interface
uses
AndroidAPI.JNIBridge,
Androidapi.JNI.JavaTypes;
type
JTelephony_Mms_Intents = interface;
JTelephony_Mms_IntentsClass = interface(JObjectClass)
['{75DFB35C-A2A5-48AD-B4F1-3997AEA1A7F5}']
function _GetCONTENT_CHANGED_ACTION : JString; cdecl; // A: $19
function _GetDELETED_CONTENTS : JString; cdecl; // A: $19
property CONTENT_CHANGED_ACTION : JString read _GetCONTENT_CHANGED_ACTION; // Ljava/lang/String; A: $19
property DELETED_CONTENTS : JString read _GetDELETED_CONTENTS; // Ljava/lang/String; A: $19
end;
[JavaSignature('android/provider/Telephony_Mms_Intents')]
JTelephony_Mms_Intents = interface(JObject)
['{1A260B97-F0BD-48CB-BFCC-504195DA35BD}']
end;
TJTelephony_Mms_Intents = class(TJavaGenericImport<JTelephony_Mms_IntentsClass, JTelephony_Mms_Intents>)
end;
const
TJTelephony_Mms_IntentsCONTENT_CHANGED_ACTION = 'android.intent.action.CONTENT_CHANGED';
TJTelephony_Mms_IntentsDELETED_CONTENTS = 'deleted_contents';
implementation
end.
|
unit SvodByGroupPrDataModul;
interface
uses
SysUtils, Classes, FIBDataSet, pFIBDataSet, FIBDatabase, pFIBDatabase,
frxClass, frxDBSet, frxDesgn, IBase, IniFiles, Forms, Dates, Variants,
Unit_SprSubs_Consts, ZProc, ZSvodTypesUnit, Controls, FIBQuery,
pFIBQuery, pFIBStoredProc, ZMessages, Dialogs, Math, Unit_SvodDocs_Consts,
frxExportXLS, DB;
type
TSvodByGroupPr_DM = class(TDataModule)
DB: TpFIBDatabase;
ReadTransaction: TpFIBTransaction;
DSetCategoryGroup: TpFIBDataSet;
ReportDSetCategoryGroup: TfrxDBDataset;
Designer: TfrxDesigner;
DSetFoundationData: TpFIBDataSet;
ReportDBDSetFoundationData: TfrxDBDataset;
Report: TfrxReport;
DSetPropPaymGroup: TpFIBDataSet;
ReportDsetPropPaymGroup: TfrxDBDataset;
DSourceFoundationData: TDataSource;
DSetUDGroup: TpFIBDataSet;
ReportDSetUDGroup: TfrxDBDataset;
DSetNotPodNalGroup: TpFIBDataSet;
ReportDSetNotPodNalGroup: TfrxDBDataset;
DsetGrSheet: TpFIBDataSet;
ReportDsetGrSheet: TfrxDBDataset;
DsetDolg: TpFIBDataSet;
ReportDsetDolg: TfrxDBDataset;
ReportUserDSet: TfrxUserDataSet;
frxXLSExport1: TfrxXLSExport;
DSetShifr: TpFIBDataSet;
ReportDSetShifr: TfrxDBDataset;
ReportDSetIput: TfrxDBDataset;
procedure ReportGetValue(const VarName: String; var Value: Variant);
procedure DataModuleDestroy(Sender: TObject);
private
PKod_Setup:Integer;
public
procedure PrintSpr(AParameter:TSvodParam; ResDateSet:TDataSet);
end;
implementation
{$R *.dfm}
const Path_IniFile_Reports = 'Reports\Zarplata\Reports.ini';
const SectionOfIniFile = 'SvodByGroupSm';
const NameReport = 'Reports\Zarplata\SvodByGroupSm.fr3';
const NameReport1 = 'Reports\Zarplata\SvodByGroupSm1.fr3';
procedure TSvodByGroupPr_DM.PrintSpr(AParameter:TSvodParam;ResDateSet:TDataSet);
var IniFile:TIniFile;
ViewMode:integer;
PathReport:string;
SummaAllDed:Extended;
SummaGr:Extended;
SummaAll:Extended;
SummaDolg:Extended;
DateForm:tdate;
i:byte;
DataSource:TDataSource;
begin
DateForm:=ConvertKodToDate(AParameter.Kod_setup);
PKod_Setup:=AParameter.Kod_setup;
DataSource:=TDataSource.create(self);
DataSource.DataSet:=ResDateSet;
ReportDSetIput.DataSet:= ResDateSet;
ResDateSet.First;
DSetFoundationData.DataSource:=DataSource;
{DSetFoundationData.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_SMETA1(:ID_TYPE_FINANCE'+','''+
DateToStr(DateForm)+''','+
IntToStr(AParameter.ID_Session)+')';
DSetCategoryGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_CATEGORY_GROUP1(?id_sm_group,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DSetPropPaymGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_PROPPAYM_GROUP1(?id_sm_group,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DSetUDGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_UD1(?id_sm_group,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''') order by KOD_VO';
DSetNotPodNalGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_NOTPODNAL1(?id_sm_group,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DsetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_GRSHEET1 (?id_sm_group,'+IntToStr(AParameter.Kod_setup)+')';
DsetDolg.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_DOLG1(?id_sm_group,'+IntToStr(AParameter.Kod_setup)+')';
DSetShifr.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_UD_SHIFR1(?id_sm_group,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';}
DSetFoundationData.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_SMETA(:ID_PKV,:ID_TYPE_FINANCE'+','''+
DateToStr(DateForm)+''','+
IntToStr(AParameter.ID_Session)+')';
DSetCategoryGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_CATEGORY_GROUP(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DSetPropPaymGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_PROPPAYM_GROUP(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DSetUDGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_UD(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''') order by KOD_VO';
DSetNotPodNalGroup.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_NOTPODNAL(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
DsetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_GRSHEET (?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.Kod_setup)+')';
DsetDolg.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_DOLG(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.Kod_setup)+')';
DSetShifr.SQLs.SelectSQL.Text := 'SELECT * FROM Z_SVODBYGROUPSM_UD_SHIFR(?ID_PKV,?ID_TYPE_FINANCE,'+IntToStr(AParameter.ID_Session)+','''+DateToStr(DateForm)+''')';
try
DB.Handle:=AParameter.DB_Handle;
ReadTransaction.starttransaction;
DSetFoundationData.Open;
//DSetFoundationData.DoSort(['ID_PKV','ID_TYPE_FINANCE'],[true,true]);
DSetCategoryGroup.Open;
DSetPropPaymGroup.Open;
DSetUDGroup.Open;
DSetNotPodNalGroup.Open;
DsetGrSheet.Open;
DsetDolg.Open;
DSetShifr.Open;
except
on E:Exception do
begin
ReadTransaction.Rollback;
ZShowMessage(Error_Caption,e.Message,mtError,[mbOK]);
Exit;
end;
end;
IniFile:=TIniFile.Create(ExtractFilePath(Application.ExeName)+Path_IniFile_Reports);
ViewMode:=IniFile.ReadInteger(SectionOfIniFile,'ViewMode',1);
PathReport:=IniFile.ReadString(SectionOfIniFile,'NameReport1',NameReport);
//else
//PathReport:=IniFile.ReadString(SectionOfIniFile,'NameReport1',NameReport1);
IniFile.Free;
Report.Clear;
Report.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
Report.Variables.Clear;
Report.Variables[' '+'User Category']:=NULL;
if zDesignReport then Report.DesignReport
else Report.ShowReport;
Report.Free;
end;
procedure TSvodByGroupPr_DM.ReportGetValue(const VarName: String; var Value: Variant);
begin
if UpperCase(VarName)='PKOD_SETUP' then
Value:=KodSetupToPeriod(PKod_Setup,4);
end;
procedure TSvodByGroupPr_DM.DataModuleDestroy(Sender: TObject);
begin
if ReadTransaction.InTransaction then ReadTransaction.Commit;
end;
end.
|
namespace;
interface
uses
System,
System.IO,
System.Web,
WindowsLive;
type
WindowsLiveAuthHandler = public partial class(System.Web.UI.Page)
const
LoginPage = 'login.aspx';
LogoutPage = LoginPage;
LoginCookie = 'webauthtoken';
class var ExpireCookie: DateTime := DateTime.Now.AddYears(-10);
class var PersistCookie: DateTime := DateTime.Now.AddYears(10);
class var WLL: WindowsLiveLogin := new WindowsLiveLogin(true);
protected
method Page_Load(sender: Object; e: EventArgs);
end;
implementation
method WindowsLiveAuthHandler.Page_Load(sender: Object; e: EventArgs);
begin
var l_req := HttpContext.Current.Request;
var l_res := HttpContext.Current.Response;
var l_action := l_req.QueryString.Get('action');
{
If action is 'logout', clear the login cookie and redirect
to the logout page.
If action is 'clearcookie', clear the login cookie and
return a GIF as response to signify success.
By default, try to process a login. If login was
successful, cache the user token in a cookie and redirect
to the site's main page. If login failed, clear the cookie
and redirect to the main page.
}
case l_action of
'logout': begin
var l_cookie := new HttpCookie(LoginCookie);
l_cookie.Expires := ExpireCookie;
l_res.Cookies.Add(l_cookie);
l_res.Redirect(LogoutPage);
l_res.End;
end;
'clearcookie': begin
var l_cookie := new HttpCookie(LoginCookie);
l_cookie.Expires := ExpireCookie;
l_res.Cookies.Add(l_cookie);
var l_type: String;
var l_content: Array of Byte;
WLL.GetClearCookieResponse(out l_type, out l_content);
l_res.ContentType := l_type;
l_res.OutputStream.Write(l_content, 0, l_content.Length);
l_res.End;
end;
else begin
var l_user := WLL.ProcessLogin(l_req.Form);
var l_cookie := new HttpCookie(LoginCookie);
if (l_user <> nil) then
begin
l_cookie.Value := l_user.Token;
if l_user.UsePersistentCookie then
begin
l_cookie.Expires := PersistCookie;
end;
end
else
begin
l_cookie.Expires := ExpireCookie;
end;
l_res.Cookies.Add(l_cookie);
l_res.Redirect(LogoutPage);
l_res.End;
end;
end;
end;
end.
|
unit SessionLock;
{ Contains session information/lock functions }
interface
uses SysUtils, Classes, Windows, UniStrUtils;
type
TSessionLock = class(TStringList)
protected
hFile: THandle;
procedure Load;
public
constructor Create(LockFile: UniString);
destructor Destroy; override;
procedure Save;
end;
implementation
constructor TSessionLock.Create(LockFile: UniString);
begin
inherited Create;
hFile := CreateFileW(PWideChar(LockFile),
GENERIC_READ or GENERIC_WRITE,
0, {exclusive access}
nil, OPEN_ALWAYS, 0, 0);
if hFile=INVALID_HANDLE_VALUE then
RaiseLastOsError();
Load;
end;
destructor TSessionLock.Destroy;
begin
if hFile<>INVALID_HANDLE_VALUE then
CloseHandle(hFile);
inherited;
end;
procedure TSessionLock.Load;
var hs: THandleStream;
begin
hs := THandleStream.Create(hFile);
try
hs.Seek(0, soBeginning);
LoadFromStream(hs);
finally
FreeAndNil(hs);
end;
end;
procedure TSessionLock.Save;
var hs: THandleStream;
begin
hs := THandleStream.Create(hFile);
try
hs.Seek(0, soBeginning);
SaveToStream(hs);
finally
FreeAndNil(hs);
end;
SetEndOfFile(hFile); {just in case}
end;
end.
|
// ************************************************************************
// ***************************** CEF4Delphi *******************************
// ************************************************************************
//
// CEF4Delphi is based on DCEF3 which uses CEF3 to embed a chromium-based
// browser in Delphi applications.
//
// The original license of DCEF3 still applies to CEF4Delphi.
//
// For more information about CEF4Delphi visit :
// https://www.briskbard.com/index.php?lang=en&pageid=cef
//
// Copyright © 2017 Salvador Díaz Fau. All rights reserved.
//
// ************************************************************************
// ************ vvvv Original license and comments below vvvv *************
// ************************************************************************
(*
* Delphi Chromium Embedded 3
*
* Usage allowed under the restrictions of the Lesser GNU General Public License
* or alternatively the restrictions of the Mozilla Public License 1.1
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* Unit owner : Henri Gourvest <hgourvest@gmail.com>
* Web site : http://www.progdigy.com
* Repository : http://code.google.com/p/delphichromiumembedded/
* Group : http://groups.google.com/group/delphichromiumembedded
*
* Embarcadero Technologies, Inc is not permitted to use or redistribute
* this source code without explicit permission.
*
*)
unit uMainForm;
{$I cef.inc}
interface
uses
{$IFDEF DELPHI16_UP}
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls,
{$ELSE}
Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms, Dialogs, StdCtrls, ExtCtrls,
{$ENDIF}
uCEFChromium, uCEFWindowParent, uCEFChromiumWindow, uCEFInterfaces, uCustomResourceHandler, uCEFConstants;
type
TMainForm = class(TForm)
ChromiumWindow1: TChromiumWindow;
AddressBarPnl: TPanel;
Edit1: TEdit;
Button1: TButton;
Timer1: TTimer;
procedure FormShow(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
private
procedure WMMove(var aMessage : TWMMove); message WM_MOVE;
procedure WMMoving(var aMessage : TMessage); message WM_MOVING;
procedure WMEnterMenuLoop(var aMessage: TMessage); message WM_ENTERMENULOOP;
procedure WMExitMenuLoop(var aMessage: TMessage); message WM_EXITMENULOOP;
protected
procedure Chromium_OnAfterCreated(Sender: TObject);
procedure Chromium_OnGetResourceHandler(Sender: TObject; const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; out Result: ICefResourceHandler);
public
{ Public declarations }
end;
var
MainForm: TMainForm;
implementation
{$R *.dfm}
uses
uCEFMiscFunctions, uCEFApplication;
procedure TMainForm.Button1Click(Sender: TObject);
begin
ChromiumWindow1.LoadURL(Edit1.Text);
end;
procedure TMainForm.FormShow(Sender: TObject);
begin
ChromiumWindow1.OnAfterCreated := Chromium_OnAfterCreated;
ChromiumWindow1.ChromiumBrowser.OnGetResourceHandler := Chromium_OnGetResourceHandler;
// GlobalCEFApp.GlobalContextInitialized has to be TRUE before creating any browser
// If it's not initialized yet, we use a simple timer to create the browser later.
if not(ChromiumWindow1.CreateBrowser) then Timer1.Enabled := True;
end;
procedure TMainForm.Timer1Timer(Sender: TObject);
begin
Timer1.Enabled := False;
if not(ChromiumWindow1.CreateBrowser) and not(ChromiumWindow1.Initialized) then
Timer1.Enabled := True;
end;
procedure TMainForm.Chromium_OnAfterCreated(Sender: TObject);
begin
ChromiumWindow1.UpdateSize;
AddressBarPnl.Enabled := True;
end;
procedure TMainForm.Chromium_OnGetResourceHandler(Sender : TObject;
const browser : ICefBrowser;
const frame : ICefFrame;
const request : ICefRequest;
out Result : ICefResourceHandler);
var
TempStream : TStringStream;
begin
// This event is called from the IO thread. Use mutexes if necessary.
TempStream := nil;
Result := nil;
try
try
TempStream := TStringStream.Create('<!DOCTYPE html><html><body><p>test</p></body></html>', TEncoding.UTF8, false);
Result := TCustomResourceHandler.Create(browser, frame, '', request, TStream(TempStream), CefGetMimeType('html'));
except
on e : exception do
if CustomExceptionHandler('TMainForm.Chromium_OnGetResourceHandler', e) then raise;
end;
finally
if (TempStream <> nil) then FreeAndNil(TempStream);
end;
end;
procedure TMainForm.WMMove(var aMessage : TWMMove);
begin
inherited;
if (ChromiumWindow1 <> nil) then ChromiumWindow1.NotifyMoveOrResizeStarted;
end;
procedure TMainForm.WMMoving(var aMessage : TMessage);
begin
inherited;
if (ChromiumWindow1 <> nil) then ChromiumWindow1.NotifyMoveOrResizeStarted;
end;
procedure TMainForm.WMEnterMenuLoop(var aMessage: TMessage);
begin
inherited;
if (aMessage.wParam = 0) and (GlobalCEFApp <> nil) then GlobalCEFApp.OsmodalLoop := True;
end;
procedure TMainForm.WMExitMenuLoop(var aMessage: TMessage);
begin
inherited;
if (aMessage.wParam = 0) and (GlobalCEFApp <> nil) then GlobalCEFApp.OsmodalLoop := False;
end;
end.
|
unit Data.API.Google;
interface
uses
System.StrUtils, Data.Articles;
type
TTextType = (ttPLAINTEXT);
TTextTypeHelper = record helper for TTextType
constructor Create(const ATextTypeCode: String);
function ToString: String;
end;
IQuery = interface
['{9DD2DF53-37BB-46BE-B91A-56613FA5132C}']
function GetText: String;
function GetTextType: TTextType;
property Text: String read GetText;
property TextType: TTextType read GetTextType;
end;
TTag = (taNOUN, taVERB, taPRON, taPRT, taPUNCT, taDET, taADJ, taADV);
TTagHelper = record helper for TTag
constructor Create(const ATagCode: String);
function ToString: String;
end;
TLabel = (laUNKNOWN, laNSUBJ, laDOBJ, laPOBJ, laATTR, laROOT, laPREP, laP,
laDET, laAMOD, laADVMOD);
TLabelHelper = record helper for TLabel
constructor Create(const ALabelCode: String);
function ToString: String;
end;
TNumber = (nuUNKNOWN, nuSINGULAR, nuPLURAL);
TNumberHelper = record helper for TNumber
constructor Create(const ANumberCode: String);
function ToString: String;
end;
TTense = (teUNKNOWN, tePRESENT);
TTenseHelper = record helper for TTense
constructor Create(const ATenseCode: String);
function ToString: String;
end;
TPerson = (peUNKNOWN, peFIRST, peSECOND, peTHIRD);
TPersonHelper = record helper for TPerson
constructor Create(const APersonCode: String);
function ToString: String;
end;
TGender = (geUNKNOWN, geMASCULINE, geFEMININE, geNEUTER);
TGenderHelper = record helper for TGender
constructor Create(const AGenderCode: String);
function ToString: String;
end;
TCase = (csUNKNOWN, csAKKUSATIVE, csDATIVE, csGENITIVE, csNOMINATIVE);
TCaseHelper = record helper for TCase
constructor Create(const ACaseCode: String);
function ToString: String;
end;
IToken = interface
['{853F36B0-8698-4A7A-8DEB-0036A4F9BFAB}']
function GetText: String;
function GetOffset: Integer;
function GetLemma: String;
function GetTag: TTag;
function GetLabel: TLabel;
function GetNumber: TNumber;
function GetTense: TTense;
function GetPerson: TPerson;
function GetGender: TGender;
function GetCase: TCase;
function GetDependency: IToken;
property Text: String read GetText;
property Offset: Integer read GetOffset;
property Lemma: String read GetLemma;
property Tag: TTag read GetTag;
property &Label: TLabel read GetLabel;
property Number: TNumber read GetNumber;
property Tense: TTense read GetTense;
property Person: TPerson read GetPerson;
property Gender: TGender read GetGender;
property &Case: TCase read GetCase;
property Dependency: IToken read GetDependency;
end;
ISentence = interface
['{FE12CEDF-AB5F-430A-979B-3DC5ED37FE43}']
function GetOffset: Integer;
function GetTokens(const AIndex: Integer): IToken;
function GetTokenCount: Integer;
property Offset: Integer read GetOffset;
property Tokens[const AIndex: Integer]: IToken read GetTokens;
property TokenCount: Integer read GetTokenCount;
end;
IGoogleArticle = interface
['{0C06D550-31BB-45C2-A5A1-F9DE920C089F}']
function GetCaption: String;
function GetSource: TSource;
function GetSentences(const AIndex: Integer): ISentence;
function GetSentenceCount: Integer;
function GetLanguage: TLanguage;
function GetSentiment: TSentiment;
function GetCategories(const AIndex: Integer): String;
function GetCategoryCount: Integer;
property Caption: String read GetCaption;
// MUST BE LOADED FROM iPOOL RESPONSE!
property Source: TSource read GetSource;
// MUST BE LOADED FROM iPOOL RESPONSE!
property Sentences[const AIndex: Integer]: ISentence read GetSentences;
property SentenceCount: Integer read GetSentenceCount;
property Language: TLanguage read GetLanguage;
property Sentiment: TSentiment read GetSentiment;
property Categories[const AIndex: Integer]: String read GetCategories;
property CategoryCount: Integer read GetCategoryCount;
end;
IGoogleArticles = interface
['{F56CB0F1-9D1B-4CB2-8C91-9FB24F1E1EE9}']
function GetArticles(const AIndex: Integer): IGoogleArticle;
function GetCount: Integer;
property Articles[const AIndex: Integer]: IGoogleArticle read GetArticles;
property Count: Integer read GetCount;
end;
IGoogleCloudAPI = interface
['{D5EFA4BC-47A7-4117-B7A6-C3C60238662D}']
function GetQuery(const AQuery: IQuery): IGoogleArticle;
property Query[const AQuery: IQuery]: IGoogleArticle read GetQuery;
end;
implementation
{ TTextTypeHelper }
constructor TTextTypeHelper.Create(const ATextTypeCode: String);
begin
Self := TTextType(IndexText(ATextTypeCode, ['PLAIN_TEXT']));
end;
function TTextTypeHelper.ToString: String;
begin
case Self of
ttPLAINTEXT:
Result := 'PLAIN_TEXT';
end;
end;
{ TTagHelper }
constructor TTagHelper.Create(const ATagCode: String);
begin
Self := TTag(IndexText(ATagCode, ['NOUN', 'VERB', 'PRON', 'PRT', 'PUNCT',
'DET', 'ADJ', 'ADV']));
end;
function TTagHelper.ToString: String;
begin
case Self of
taNOUN:
Result := 'NOUN';
taVERB:
Result := 'VERB';
taPRON:
Result := 'PRON';
taPRT:
Result := 'PRT';
taPUNCT:
Result := 'PUNCT';
taDET:
Result := 'DET';
taADJ:
Result := 'ADJ';
taADV:
Result := 'ADV';
end;
end;
{ TLabelHelper }
constructor TLabelHelper.Create(const ALabelCode: String);
begin
Self := TLabel(IndexText(ALabelCode, ['UNKNOWN', 'NSUBJ', 'DOBJ', 'POBJ',
'ATTR', 'ROOT', 'PREP', 'P', 'DET', 'AMOD', 'ADVMOD']));
end;
function TLabelHelper.ToString: String;
begin
case Self of
laUNKNOWN:
Result := 'UNKNOWN';
laNSUBJ:
Result := 'NSUBJ';
laDOBJ:
Result := 'DOBJ';
laPOBJ:
Result := 'POBJ';
laATTR:
Result := 'ATTR';
laROOT:
Result := 'ROOT';
laPREP:
Result := 'PREP';
laP:
Result := 'P';
laDET:
Result := 'DET';
laAMOD:
Result := 'AMOD';
laADVMOD:
Result := 'ADVMOD';
end;
end;
{ TNumberHelper }
constructor TNumberHelper.Create(const ANumberCode: String);
begin
Self := TNumber(IndexText(ANumberCode, ['NUMBER_UNKNOWN', 'SINGULAR',
'PLURAL']));
end;
function TNumberHelper.ToString: String;
begin
case Self of
nuUNKNOWN:
Result := 'NUMBER_UNKNOWN';
nuSINGULAR:
Result := 'SINGULAR';
nuPLURAL:
Result := 'PLURAL';
end;
end;
{ TTenseHelper }
constructor TTenseHelper.Create(const ATenseCode: String);
begin
Self := TTense(IndexText(ATenseCode, ['TENSE_UNKNOWN', 'PRESENT']));
end;
function TTenseHelper.ToString: String;
begin
case Self of
teUNKNOWN:
Result := 'TENSE_UNKNOWN';
tePRESENT:
Result := 'PRESENT';
end;
end;
{ TPersonHelper }
constructor TPersonHelper.Create(const APersonCode: String);
begin
Self := TPerson(IndexText(APersonCode, ['PERSON_UNKNOWN', 'FIRST', 'SECOND',
'THIRD']));
end;
function TPersonHelper.ToString: String;
begin
case Self of
peUNKNOWN:
Result := 'PERSON_UNKNOWN';
peFIRST:
Result := 'FIRST';
peSECOND:
Result := 'SECOND';
peTHIRD:
Result := 'THIRD';
end;
end;
{ TGenderHelper }
constructor TGenderHelper.Create(const AGenderCode: String);
begin
Self := TGender(IndexText(AGenderCode, ['GENDER_UNKNOWN', 'MASCULINE',
'FEMININE', 'NEUTER']));
end;
function TGenderHelper.ToString: String;
begin
case Self of
geUNKNOWN:
Result := 'GENDER_UNKNOWN';
geMASCULINE:
Result := 'MASCULINE';
geFEMININE:
Result := 'FEMININE';
geNEUTER:
Result := 'NEUTER';
end;
end;
{ TCaseHelper }
constructor TCaseHelper.Create(const ACaseCode: String);
begin
Self := TCase(IndexText(ACaseCode, ['CASE_UNKNOWN', 'AKKUSATIVE', 'DATIVE',
'GENITIVE', 'NOMINATIVE']));
end;
function TCaseHelper.ToString: String;
begin
case Self of
csUNKNOWN:
Result := 'CASE_UNKNOWN';
csAKKUSATIVE:
Result := 'AKKUSATIVE';
csDATIVE:
Result := 'DATIVE';
csGENITIVE:
Result := 'GENITIVE';
csNOMINATIVE:
Result := 'NOMINATIVE';
end;
end;
end.
|
unit uCliente;
interface
uses Generics.Collections, Rest.Json;
type
TExtraClass = class
private
public
function ToJsonString: string;
class function FromJsonString(AJsonString: string): TExtraClass;
end;
TQsaClass = class
private
FNome: String;
FQual: String;
public
property nome: String read FNome write FNome;
property qual: String read FQual write FQual;
function ToJsonString: string;
class function FromJsonString(AJsonString: string): TQsaClass;
end;
TAtividades_secundariasClass = class
private
FCode: String;
FText: String;
public
property code: String read FCode write FCode;
property text: String read FText write FText;
function ToJsonString: string;
class function FromJsonString(AJsonString: string): TAtividades_secundariasClass;
end;
TAtividade_principalClass = class
private
FCode: String;
FText: String;
public
property code: String read FCode write FCode;
property text: String read FText write FText;
function ToJsonString: string;
class function FromJsonString(AJsonString: string): TAtividade_principalClass;
end;
TClienteClass = class
private
FAbertura: String;
FAtividade_principal: TArray<TAtividade_principalClass>;
FAtividades_secundarias: TArray<TAtividades_secundariasClass>;
FBairro: String;
FCapital_social: String;
FCep: String;
FCnpj: String;
FComplemento: String;
FData_situacao: String;
FData_situacao_especial: String;
FEfr: String;
FEmail: String;
FExtra: TExtraClass;
FFantasia: String;
FLogradouro: String;
FMotivo_situacao: String;
FMunicipio: String;
FNatureza_juridica: String;
FNome: String;
FNumero: String;
FQsa: TArray<TQsaClass>;
FSituacao: String;
FSituacao_especial: String;
FStatus: String;
FTelefone: String;
FTipo: String;
FUf: String;
FUltima_atualizacao: String;
public
property abertura: String read FAbertura write FAbertura;
property atividade_principal: TArray<TAtividade_principalClass> read FAtividade_principal write FAtividade_principal;
property atividades_secundarias: TArray<TAtividades_secundariasClass> read FAtividades_secundarias write FAtividades_secundarias;
property bairro: String read FBairro write FBairro;
property capital_social: String read FCapital_social write FCapital_social;
property cep: String read FCep write FCep;
property cnpj: String read FCnpj write FCnpj;
property complemento: String read FComplemento write FComplemento;
property data_situacao: String read FData_situacao write FData_situacao;
property data_situacao_especial: String read FData_situacao_especial write FData_situacao_especial;
property efr: String read FEfr write FEfr;
property email: String read FEmail write FEmail;
property extra: TExtraClass read FExtra write FExtra;
property fantasia: String read FFantasia write FFantasia;
property logradouro: String read FLogradouro write FLogradouro;
property motivo_situacao: String read FMotivo_situacao write FMotivo_situacao;
property municipio: String read FMunicipio write FMunicipio;
property natureza_juridica: String read FNatureza_juridica write FNatureza_juridica;
property nome: String read FNome write FNome;
property numero: String read FNumero write FNumero;
property qsa: TArray<TQsaClass> read FQsa write FQsa;
property situacao: String read FSituacao write FSituacao;
property situacao_especial: String read FSituacao_especial write FSituacao_especial;
property status: String read FStatus write FStatus;
property telefone: String read FTelefone write FTelefone;
property tipo: String read FTipo write FTipo;
property uf: String read FUf write FUf;
property ultima_atualizacao: String read FUltima_atualizacao write FUltima_atualizacao;
constructor Create;
destructor Destroy; override;
function ToJsonString: string;
class function FromJsonString(AJsonString: string): TClienteClass;
end;
implementation
{TExtraClass}
function TExtraClass.ToJsonString: string;
begin
result := TJson.ObjectToJsonString(self);
end;
class function TExtraClass.FromJsonString(AJsonString: string): TExtraClass;
begin
result := TJson.JsonToObject<TExtraClass>(AJsonString)
end;
{TQsaClass}
function TQsaClass.ToJsonString: string;
begin
result := TJson.ObjectToJsonString(self);
end;
class function TQsaClass.FromJsonString(AJsonString: string): TQsaClass;
begin
result := TJson.JsonToObject<TQsaClass>(AJsonString)
end;
{TAtividades_secundariasClass}
function TAtividades_secundariasClass.ToJsonString: string;
begin
result := TJson.ObjectToJsonString(self);
end;
class function TAtividades_secundariasClass.FromJsonString(AJsonString: string): TAtividades_secundariasClass;
begin
result := TJson.JsonToObject<TAtividades_secundariasClass>(AJsonString)
end;
{TAtividade_principalClass}
function TAtividade_principalClass.ToJsonString: string;
begin
result := TJson.ObjectToJsonString(self);
end;
class function TAtividade_principalClass.FromJsonString(AJsonString: string): TAtividade_principalClass;
begin
result := TJson.JsonToObject<TAtividade_principalClass>(AJsonString)
end;
{TClienteClass}
constructor TClienteClass.Create;
begin
inherited;
FExtra := TExtraClass.Create();
end;
destructor TClienteClass.Destroy;
var
Latividade_principalItem: TAtividade_principalClass;
Latividades_secundariasItem: TAtividades_secundariasClass;
LqsaItem: TQsaClass;
begin
for Latividade_principalItem in FAtividade_principal do
Latividade_principalItem.free;
for Latividades_secundariasItem in FAtividades_secundarias do
Latividades_secundariasItem.free;
for LqsaItem in FQsa do
LqsaItem.free;
FExtra.free;
inherited;
end;
function TClienteClass.ToJsonString: string;
begin
result := TJson.ObjectToJsonString(self);
end;
class function TClienteClass.FromJsonString(AJsonString: string): TClienteClass;
begin
result := TJson.JsonToObject<TClienteClass>(AJsonString)
end;
end.
|
unit ibSHDriverIntf;
interface
uses
SHDesignIntf,
SysUtils, Classes, DB, Graphics, Types;
type
TibErrorCode= record
SQLCode :Integer;
IBErrorCode:Integer;
end;
IibSHDRV = interface(ISHDRVNativeDAC)
['{98EFE313-1125-4220-9BDE-E95ADEA8EEB5}']
function GetErrorText: string;
function GetLastErrorCode:TibErrorCode;
property ErrorText: string read GetErrorText;
property LastErrorCode:TibErrorCode read GetLastErrorCode;
end;
IibSHDRVDatabase = interface(IibSHDRV)
['{86D7A41A-2CA0-4AEA-BF0F-CA5C4C4AD343}']
function GetDatabase: string;
procedure SetDatabase(Value: string);
function GetCharset: string;
procedure SetCharset(Value: string);
function GetUserName: string;
procedure SetUserName(Value: string);
function GetPassword: string;
procedure SetPassword(Value: string);
function GetRoleName: string;
procedure SetRoleName(Value: string);
function GetLoginPrompt: Boolean;
procedure SetLoginPrompt(Value: Boolean);
function GetOnLostConnect: TNotifyEvent;
procedure SetOnLostConnect(Value: TNotifyEvent);
function GetDBParams: TStrings;
procedure SetDBParams(Value: TStrings);
function GetClientLibrary: string;
procedure SetClientLibrary(Value: string);
function GetSQLDialect: Integer;
procedure SetSQLDialect(Value: Integer);
function GetCapitalizeNames: Boolean;
procedure SetCapitalizeNames(Value: Boolean);
function GetConnected: Boolean;
procedure SetConnected(Value: Boolean);
function GetUserNames: TStrings;
function GetODSVersion: string;
function GetPageSize: Integer;
function GetAllocationPages: Integer;
function GetPageBuffers: Integer;
function GetSweepInterval: Integer;
function GetForcedWrites: Boolean;
function GetReadOnly: Boolean;
function Connect: Boolean;
function Reconnect: Boolean;
function Disconnect: Boolean;
procedure CreateDatabase;
procedure DropDatabase;
function TestConnection: Boolean;
procedure ClearCache;
function IsFirebirdConnect:boolean;
property Database: string read GetDatabase write SetDatabase;
property Charset: string read GetCharset write SetCharset;
property UserName: string read GetUserName write SetUserName;
property Password: string read GetPassword write SetPassword;
property RoleName: string read GetRoleName write SetRoleName;
property LoginPrompt: Boolean read GetLoginPrompt write SetLoginPrompt;
property OnLostConnect: TNotifyEvent read GetOnLostConnect write SetOnLostConnect;
property DBParams: TStrings read GetDBParams write SetDBParams;
property ClientLibrary: string read GetClientLibrary write SetClientLibrary;
property SQLDialect: Integer read GetSQLDialect write SetSQLDialect;
property CapitalizeNames: Boolean read GetCapitalizeNames write SetCapitalizeNames;
property Connected: Boolean read GetConnected write SetConnected;
property UserNames: TStrings read GetUserNames;
// for Services
property ODSVersion: string read GetODSVersion;
property PageSize: Integer read GetPageSize;
property AllocationPages: Integer read GetAllocationPages;
property PageBuffers: Integer read GetPageBuffers;
property SweepInterval: Integer read GetSweepInterval;
property ForcedWrites: Boolean read GetForcedWrites;
property ReadOnly: Boolean read GetReadOnly;
end;
IibSHDRVQuery = interface;
IibSHDRVDatabaseExt= interface
['{C43EC85D-4954-47CE-A2E6-E5CEEE424DB3}']
//Buzz
function GetRecordCountSelect(const ForSQL:string):string;
function IsTableOrView(const ObjectName:string):boolean;
end;
IibSHDRVTransactionNotification = interface;
IibSHDRVTransaction = interface(IibSHDRV)
['{49FD11E9-6F83-4278-AFCF-16B0612C139A}']
function GetNativeDAC: TObject;
function GetDatabase: IibSHDRVDatabase;
procedure SetDatabase(const Value: IibSHDRVDatabase);
function GetParams: TStrings;
procedure SetParams(Value: TStrings);
function GetTransactionNotification: IibSHDRVTransactionNotification;
procedure SetTransactionNotification(Value: IibSHDRVTransactionNotification);
function InTransaction: Boolean;
procedure StartTransaction;
function Commit: Boolean;
function CommitRetaining: Boolean;
function Rollback: Boolean;
function RollbackRetaining: Boolean;
property Database: IibSHDRVDatabase read GetDatabase write SetDatabase;
property Params: TStrings read GetParams write SetParams;
property TransactionNotification: IibSHDRVTransactionNotification
read GetTransactionNotification write SetTransactionNotification;
end;
TibSHTransactionAction = (shtaRollback, shtaCommit);
IibSHDRVTransactionNotification = interface
['{E36EB3DF-182E-43EA-8E18-DA078E313122}']
procedure AfterEndTransaction(ATransaction: IibSHDRVTransaction;
ATransactionAction: TibSHTransactionAction);
end;
IibSHDRVQuery = interface(IibSHDRV)
['{F7E49604-F184-49B9-908F-62B7020FC520}']
function GetDatabase: IibSHDRVDatabase;
procedure SetDatabase(const Value: IibSHDRVDatabase);
function GetTransaction: IibSHDRVTransaction;
procedure SetTransaction(const Value: IibSHDRVTransaction);
function GetSQL: TStrings;
procedure SetSQL(Value: TStrings);
function GetParamCheck: Boolean;
procedure SetParamCheck(Value: Boolean);
function GetPlan: string;
function GetActive: Boolean;
function GetBof: Boolean;
function GetEof: Boolean;
function GetPrepared: Boolean;
function ExecSQL(const SQLText: string; const AParams: array of Variant; AutoCommit: Boolean; KeepPrepared:boolean=False ): Boolean;
// function ExecSQL(const SQLText: string; const AParams: array of Variant; AutoCommit: Boolean): Boolean;
function Prepare: Boolean;
function Execute: Boolean;
procedure Next;
procedure Close;
function FieldExists(const FieldName: string): Boolean;
function FieldName(FieldNo: Integer): string;
function FieldIsBlob(FieldNo: Integer): Boolean;
function GetFieldValue(const FieldName: string): Variant; overload;
function GetFieldValue(FieldNo: Integer): Variant; overload;
function GetFieldStrValue(const FieldName: string): string; overload;
function GetFieldStrValue(FieldNo: Integer): string; overload;
function GetFieldIntValue(const FieldName: string): Integer; overload;
function GetFieldIntValue(FieldNo: Integer): Integer; overload;
function GetFieldInt64Value(const FieldName: string): Int64; overload;
function GetFieldInt64Value(FieldNo: Integer): Int64; overload;
function GetFieldFloatValue(const FieldName: string): Double; overload;
function GetFieldFloatValue(FieldNo: Integer): Double; overload;
function GetFieldIsNull(const FieldName: string): Boolean; overload;
function GetFieldIsNull(FieldNo: Integer): Boolean; overload;
function GetFieldSize(const FieldName: string): Integer; overload;
function GetFieldSize(FieldNo: Integer): Integer; overload;
function GetFieldCount: Integer;
function GetDebugFieldValue(Index:integer): Variant;
property Database: IibSHDRVDatabase read GetDatabase write SetDatabase;
property Transaction: IibSHDRVTransaction read GetTransaction write SetTransaction;
property SQL: TStrings read GetSQL write SetSQL;
property ParamCheck: Boolean read GetParamCheck write SetParamCheck;
property Plan: string read GetPlan;
property Active: Boolean read GetActive;
property Bof: Boolean read GetBof;
property Eof: Boolean read GetEof;
property Prepared: Boolean read GetPrepared;
end;
IibDRVDatasetNotification = interface;
IibSHDRVDataset = interface(IibSHDRV)
['{EE948FF6-D1EC-4946-8911-BA60C964AAEC}']
function GetActive: Boolean;
procedure SetActive(Value: Boolean);
function GetAutoCommit: Boolean;
procedure SetAutoCommit(Value: Boolean);
function GetDatabase: IibSHDRVDatabase;
procedure SetDatabase(const Value: IibSHDRVDatabase);
function GetReadTransaction: IibSHDRVTransaction;
procedure SetReadTransaction(const Value: IibSHDRVTransaction);
function GetWriteTransaction: IibSHDRVTransaction;
procedure SetWriteTransaction(const Value: IibSHDRVTransaction);
function GetSelectSQL: TStrings;
procedure SetSelectSQL(Value: TStrings);
function GetInsertSQL: TStrings;
procedure SetInsertSQL(Value: TStrings);
function GetUpdateSQL: TStrings;
procedure SetUpdateSQL(Value: TStrings);
function GetDeleteSQL: TStrings;
procedure SetDeleteSQL(Value: TStrings);
function GetRefreshSQL: TStrings;
procedure SetRefreshSQL(Value: TStrings);
function GetDataset: TDataset;
function GetPlan: string;
function GetDataModified: Boolean;
function GetDatasetNotification: IibDRVDatasetNotification;
procedure SetDatasetNotification(Value: IibDRVDatasetNotification);
function GetIsFetching: Boolean;
procedure SetIsFetching(Value: Boolean);
function GetIsEmpty: Boolean;
function GetFilter: string;
procedure SetFilter(Value: string);
function GetRelationTableName(FieldIndex: Integer):string;
function GetRelationFieldName(FieldIndex: Integer):string;
function Prepare: Boolean;
procedure Open;
procedure FetchAll;
procedure Close;
procedure CrearAllSQLs;
procedure GenerateSQLs(const ATableName, AKeyFields: string; AllFieldsUsed: Boolean);
procedure SetAutoGenerateSQLsParams(const ATableName, AKeyFields: string; AllFieldsUsed: Boolean);
procedure DoSort(Fields: array of const; Ordering: array of Boolean);
function GetDebugFieldValue(Index:integer): Variant;
property Active: Boolean read GetActive write SetActive;
property AutoCommit: Boolean read GetAutoCommit write SetAutoCommit;
property Database: IibSHDRVDatabase read GetDatabase write SetDatabase;
property ReadTransaction: IibSHDRVTransaction read GetReadTransaction write SetReadTransaction;
property WriteTransaction: IibSHDRVTransaction read GetWriteTransaction write SetWriteTransaction;
property SelectSQL: TStrings read GetSelectSQL write SetSelectSQL;
property InsertSQL: TStrings read GetInsertSQL write SetInsertSQL;
property UpdateSQL: TStrings read GetUpdateSQL write SetUpdateSQL;
property DeleteSQL: TStrings read GetDeleteSQL write SetDeleteSQL;
property RefreshSQL: TStrings read GetRefreshSQL write SetRefreshSQL;
property Dataset: TDataset read GetDataset;
property Plan: string read GetPlan;
property DataModified: Boolean read GetDataModified;
property IsFetching: Boolean read GetIsFetching write SetIsFetching;
property IsEmpty: Boolean read GetIsEmpty;
property Filter: string read GetFilter write SetFilter;
property DatasetNotification: IibDRVDatasetNotification
read GetDatasetNotification
write SetDatasetNotification;
end;
IibDRVDatasetNotification = interface
['{C1793100-6553-489E-AB82-31B5691AAA0F}']
procedure AfterOpen(ADataset: IibSHDRVDataset);
procedure OnFetchRecord(ADataset: IibSHDRVDataset);
procedure OnError(ADataset: IibSHDRVDataset);
end;
TibSHOnSQLNotify = procedure (EventText: String; EventTime: TDateTime) of object;
IibSHDRVMonitor = interface(IibSHDRV)
['{7CC54C4F-5F1A-49FF-9281-CB485EA64005}']
function GetActive: Boolean;
procedure SetActive(Value: Boolean);
function GetTracePrepare: Boolean;
procedure SetTracePrepare(Value: Boolean);
function GetTraceExecute: Boolean;
procedure SetTraceExecute(Value: Boolean);
function GetTraceFetch: Boolean;
procedure SetTraceFetch(Value: Boolean);
function GetTraceConnect: Boolean;
procedure SetTraceConnect(Value: Boolean);
function GetTraceTransact: Boolean;
procedure SetTraceTransact(Value: Boolean);
function GetTraceService: Boolean;
procedure SetTraceService(Value: Boolean);
function GetTraceStmt: Boolean;
procedure SetTraceStmt(Value: Boolean);
function GetTraceError: Boolean;
procedure SetTraceError(Value: Boolean);
function GetTraceBlob: Boolean;
procedure SetTraceBlob(Value: Boolean);
function GetTraceMisc: Boolean;
procedure SetTraceMisc(Value: Boolean);
function GetOnSQL: TibSHOnSQLNotify;
procedure SetOnSQL(Value: TibSHOnSQLNotify);
property Active: Boolean read GetActive write SetActive;
property TracePrepare: Boolean read GetTracePrepare write SetTracePrepare;
property TraceExecute: Boolean read GetTraceExecute write SetTraceExecute;
property TraceFetch: Boolean read GetTraceFetch write SetTraceFetch;
property TraceConnect: Boolean read GetTraceConnect write SetTraceConnect;
property TraceTransact: Boolean read GetTraceTransact write SetTraceTransact;
property TraceService: Boolean read GetTraceService write SetTraceService;
property TraceStmt: Boolean read GetTraceStmt write SetTraceStmt;
property TraceError: Boolean read GetTraceError write SetTraceError;
property TraceBlob: Boolean read GetTraceBlob write SetTraceBlob;
property TraceMisc: Boolean read GetTraceMisc write SetTraceMisc;
property OnSQL: TibSHOnSQLNotify read GetOnSQL write SetOnSQL;
end;
IibSHDRVSQLParserNotification = interface;
IibSHDRVSQLParser = interface(IibSHDRV)
['{EB0EE766-2DB5-441D-9B19-2E741803EE5D}']
function GetScript: TStrings;
function GetCount: Integer;
function GetStatements(Index: Integer): string;
function GetTerminator: string;
procedure SetTerminator(const Value: string);
function GetSQLParserNotification: IibSHDRVSQLParserNotification;
procedure SetSQLParserNotification(Value: IibSHDRVSQLParserNotification);
function Parse(const SQLText: string): Boolean; overload;
function Parse: Boolean; overload;
function StatementState(const Index: Integer): TSHDBComponentState;
function StatementObjectType(const Index: Integer): TGUID;
function StatementObjectName(const Index: Integer): string;
function StatementsCoord(Index: Integer): TRect;
function StatementOperationName(Index: Integer): string;
function IsDataSQL(Index: Integer): Boolean;
property Script: TStrings read GetScript;
property Count: Integer read GetCount;
property Statements[Index: Integer]: string read GetStatements;
property Terminator: string read GetTerminator write SetTerminator;
property SQLParserNotification: IibSHDRVSQLParserNotification
read GetSQLParserNotification write SetSQLParserNotification;
end;
IibSHDRVSQLParserNotification = interface
['{85110C56-F6C8-4445-BF22-D39E68FC36E7}']
procedure OnParse(ASQLParser: IibSHDRVSQLParser);
end;
IibSHDRVPlayerNotification = interface;
IibSHDRVPlayer = interface(IibSHDRV)
['{4E45A517-151C-4784-BD78-CE41C0CACD35}']
function GetAutoDDL: Boolean;
procedure SetAutoDDL(Value: Boolean);
function GetScript: TStrings;
function GetPaused: Boolean;
procedure SetPaused(Value: Boolean);
function GetDatabase: IibSHDRVDatabase;
procedure SetDatabase(const Value: IibSHDRVDatabase);
function GetTransaction: IibSHDRVTransaction;
procedure SetTransaction(const Value: IibSHDRVTransaction);
function GetSQLDialect: Integer;
procedure SetSQLDialect(Value: Integer);
function GetParser: IibSHDRVSQLParser;
procedure SetParser(Value: IibSHDRVSQLParser);
function GetPlayerNotification: IibSHDRVPlayerNotification;
procedure SetPlayerNotification(Value: IibSHDRVPlayerNotification);
function GetLineProceeding: Integer;
function GetInputStringCount: Integer;
function GetTerminator: string;
procedure SetTerminator(const Value: string);
procedure Execute;
property AutoDDL: Boolean read GetAutoDDL write SetAutoDDL;
property Script: TStrings read GetScript;
property Paused: Boolean read GetPaused write SetPaused;
property Database: IibSHDRVDatabase read GetDatabase write SetDatabase;
property Transaction: IibSHDRVTransaction read GetTransaction
write SetTransaction;
property SQLDialect: Integer read GetSQLDialect write SetSQLDialect;
property Parser: IibSHDRVSQLParser read GetParser write SetParser;
property PlayerNotification: IibSHDRVPlayerNotification
read GetPlayerNotification write SetPlayerNotification;
property LineProceeding: Integer read GetLineProceeding;
property InputStringCount: Integer read GetInputStringCount;
property Terminator: string read GetTerminator write SetTerminator;
end;
IibSHDRVPlayerNotification = interface
['{A0C61F2B-9981-4578-BFC7-497B36F41A3D}']
procedure OnParse(APlayer: IibSHDRVPlayer;const ASQLText: string;
ALineIndex: Integer);
procedure OnError(APlayer: IibSHDRVPlayer; const AError: string;
const ASQLText: string; ALineIndex: Integer; var DoAbort: Boolean;
var DoRollbackOnError: Boolean);
procedure AfterExecute(APlayer: IibSHDRVPlayer; ATokens: TStrings;
const ASQLText: string);
procedure BeforeExecuteStmnt(APlayer: IibSHDRVPlayer;
StmntNo:integer;AScriptLine: Integer
);
end;
TibSHServiceType = (stUnknown, stServerProperties, stConfigService, stLicensingService,
stLogService, stStatisticalService, stBackupService,
stRestoreService, stValidationService, stSecurityService);
IibSHDRVService = interface(IibSHDRV)
['{BE2EA9C1-22B4-47E4-AE4D-F06EA39B2DC1}']
function GetActive: Boolean;
function GetServiceType: TibSHServiceType;
function GetConnectProtocol: string;
procedure SetConnectProtocol(Value: string);
function GetConnectPort: string;
procedure SetConnectPort(Value: string);
function GetConnectLibraryName: string;
procedure SetConnectLibraryName(Value: string);
function GetConnectLoginPrompt: Boolean;
procedure SetConnectLoginPrompt(Value: Boolean);
function GetConnectUser: string;
procedure SetConnectUser(Value: string);
function GetConnectPassword: string;
procedure SetConnectPassword(Value: string);
function GetConnectRole: string;
procedure SetConnectRole(Value: string);
function GetConnectServer: string;
procedure SetConnectServer(Value: string);
function GetConnectDatabase: string;
procedure SetConnectDatabase(Value: string);
function Attach(AServiceType: TibSHServiceType; OnText: TSHOnTextNotify = nil): Boolean;
function Detach: Boolean;
// Server Users
procedure DisplayUsers;
function UserCount: Integer;
function GetUserName(AIndex: Integer): string;
function GetFirstName(AIndex: Integer): string;
function GetMiddleName(AIndex: Integer): string;
function GetLastName(AIndex: Integer): string;
function AddUser(const UserName, Password, FirstName, MiddleName, LastName: string): Boolean;
function DeleteUser(const UserName: string): Boolean;
function ModifyUser(const UserName, Password, FirstName, MiddleName, LastName: string): Boolean;
// Server Properties
procedure DisplayLocationInfo;
function GetBaseFileLocation: string;
function GetLockFileLocation: string;
function GetMessageFileLocation: string;
function GetSecurityLocation: string;
procedure DisplayServerInfo;
function GetServerVersion: string;
function GetServerImplementation: string;
function GetServiceVersion: string;
procedure DisplayDatabaseInfo;
function GetNumberOfAttachments: string;
function GetNumberOfDatabases: string;
function GetDatabaseName(AIndex: Integer): string;
procedure DisplayLicenseInfo;
function GetLicensedUsers: string;
function GetLicensedKeyCount: Integer;
function GetLicensedKey(AIndex: Integer): string;
function GetLicensedID(AIndex: Integer): string;
function GetLicensedDesc(AIndex: Integer): string;
procedure DisplayConfigInfo;
function GetISCCFG_XXX_KEY(AKey: Integer): Integer; // Look "Server configuration key values" in ibase.pas
// Server Log
function DisplayServerLog: Boolean;
// Database Statistics
// AStopIndex = { 0 (Header Page) | 1 (Log Pages) | 2 (Index Pages) | 3 (Data Pages) | 4 (System Relations)}
function DisplayDatabaseStatistics(const AStopIndex: Integer; ATableName: string = ''): Boolean;
// Database Validations
function DisplayDatabaseValidation(const ARecordFragments, AReadOnly, AIgnoreChecksum, AKillShadows: Boolean): Boolean;
function DisplayDatabaseSweep(const AIgnoreChecksum: Boolean): Boolean;
function DisplayDatabaseMend(const AIgnoreChecksum: Boolean): Boolean;
function DisplayLimboTransactions: Boolean;
function GetLimboTransactionCount: Integer;
function GetLimboTransactionMultiDatabase(const AIndex: Integer): Boolean;
function GetLimboTransactionID(const AIndex: Integer): Integer;
function GetLimboTransactionHostSite(const AIndex: Integer): string;
function GetLimboTransactionRemoteSite(const AIndex: Integer): string;
function GetLimboTransactionRemoteDatabasePath(const AIndex: Integer): string;
function GetLimboTransactionState(const AIndex: Integer): string;
function GetLimboTransactionAdvise(const AIndex: Integer): string;
function GetLimboTransactionAction(const AIndex: Integer): string;
// Database Online
function DisplayDatabaseOnline: Boolean;
// Database Shutdown
// AModeIndex = { 0 (Forced) | 1 (DenyTransaction) | 2 (DenyAttachment) }
function DisplayDatabaseShutdown(const AModeIndex, ATimeout: Integer): Boolean;
// Database Backup
function DisplayBackup(const ASourceFileList, ADestinationFileList: TStrings;
const ATransportable, AMetadataOnly, ANoGarbageCollect, AIgnoreLimboTrans,
AIgnoreChecksums, AOldMetadataDesc, AConvertExtTables, AVerbose: Boolean): Boolean;
// Database Restore
function DisplayRestore(const ASourceFileList, ADestinationFileList: TStrings;
const APageSize: Integer;
const AReplaceExisting, AMetadataOnly, ACommitEachTable, AWithoutShadow,
ADeactivateIndexes, ANoValidityCheck, AUseAllSpace, AVerbose: Boolean): Boolean;
// Database Properties
procedure SetPageBuffers(Value: Integer);
procedure SetSQLDialect(Value: Integer);
procedure SetSweepInterval(Value: Integer);
procedure SetForcedWrites(Value: Boolean);
procedure SetReadOnly(Value: Boolean);
property Active: Boolean read GetActive;
property ServiceType: TibSHServiceType read GetServiceType;
property ConnectProtocol: string read GetConnectProtocol write SetConnectProtocol;
property ConnectPort: string read GetConnectPort write SetConnectPort;
property ConnectLibraryName: string read GetConnectLibraryName write SetConnectLibraryName;
property ConnectLoginPrompt: Boolean read GetConnectLoginPrompt write SetConnectLoginPrompt;
property ConnectUser: string read GetConnectUser write SetConnectUser;
property ConnectPassword: string read GetConnectPassword write SetConnectPassword;
property ConnectRole: string read GetConnectRole write SetConnectRole;
property ConnectServer: string read GetConnectServer write SetConnectServer;
property ConnectDatabase: string read GetConnectDatabase write SetConnectDatabase;
end;
IibSHDRVParams = interface
['{4098C522-09B8-41FF-AE70-8CD433FAE991}']
function GetParamByIndex(Index: Integer): Variant;
procedure SetParamByIndex(Index: Integer; Value: Variant);
function GetParamIsNull(Index: Integer): Boolean;
procedure SetParamIsNull(Index: Integer; Value: Boolean);
function GetParamCount: Integer;
function ParamExists(const ParamName: string): Boolean;
function ParamName(ParamNo: Integer): string;
function GetParamSize(const ParamName: string): Integer; overload;
function GetParamSize(ParamNo: Integer): Integer; overload;
function GetParamByName(const ParamName: string): Variant;
procedure SetParamByName(const ParamName: string; Value: Variant);
property ParamByIndex[Index: Integer]: Variant read GetParamByIndex write SetParamByIndex;
property ParamIsNull[Index: Integer]: Boolean read GetParamIsNull write SetParamIsNull;
property ParamCount: Integer read GetParamCount;
end;
IibSHDRVExecTimeStatistics = interface
['{E29DB38E-A88E-4452-9814-9B2284D15AB6}']
function GetPrepareTime: Cardinal;
function GetExecuteTime: Cardinal;
function GetFetchTime: Cardinal;
property PrepareTime: Cardinal read GetPrepareTime;
property ExecuteTime: Cardinal read GetExecuteTime;
property FetchTime: Cardinal read GetFetchTime;
end;
IibSHDRVTableStatistics = interface
['{BD0D09F4-C0A8-4CC5-AFFA-7DD0622DAE7C}']
function GetTableName: string;
function GetIdxReads: Integer;
function GetSeqReads: Integer;
function GetUpdates: Integer;
function GetInserts: Integer;
function GetDeletes: Integer;
function GetBackout: Integer;
function GetExpunge: Integer;
function GetPurge: Integer;
property TableName: string read GetTableName;
property IdxReads: Integer read GetIdxReads;
property SeqReads: Integer read GetSeqReads;
property Updates: Integer read GetUpdates;
property Inserts: Integer read GetInserts;
property Deletes: Integer read GetDeletes;
property Backout: Integer read GetBackout;
property Expunge: Integer read GetExpunge;
property Purge: Integer read GetPurge;
end;
IibSHDRVStatistics = interface(IibSHDRV)
['{12C20D76-0200-4334-A4C2-A98C655F64E8}']
function GetIdxReads: Integer;
function GetSeqReads: Integer;
function GetUpdates: Integer;
function GetDeletes: Integer;
function GetInserts: Integer;
function GetAllFetches: Integer;
function GetFetches: Integer;
function GetAllMarks: Integer;
function GetMarks: Integer;
function GetAllReads: Integer;
function GetReads: Integer;
function GetAllWrites: Integer;
function GetWrites: Integer;
function GetTableStatistics(Index: Integer): IibSHDRVTableStatistics;
function GetTablesCount: Integer;
function GetSnapshotTime: TDateTime;
function GetCurrentMemory: Integer;
function GetMaxMemory: Integer;
function GetNumBuffers: Integer;
function GetDatabasePageSize: Integer;
function GetDatabase: IibSHDRVDatabase;
procedure SetDatabase(const Value: IibSHDRVDatabase);
procedure StartCollection;
procedure CalculateStatistics;
property IdxReads: Integer read GetIdxReads;
property SeqReads: Integer read GetSeqReads;
property Updates: Integer read GetUpdates;
property Deletes: Integer read GetDeletes;
property Inserts: Integer read GetInserts;
property AllFetches: Integer read GetAllFetches;
property Fetches: Integer read GetFetches;
property AllMarks: Integer read GetAllMarks;
property Marks: Integer read GetMarks;
property AllReads: Integer read GetAllReads;
property Reads: Integer read GetReads;
property AllWrites: Integer read GetAllWrites;
property Writes: Integer read GetWrites;
property TableStatistics[Index: Integer]: IibSHDRVTableStatistics read GetTableStatistics;
property TablesCount: Integer read GetTablesCount;
property SnapshotTime: TDateTime read GetSnapshotTime;
property CurrentMemory: Integer read GetCurrentMemory;
property MaxMemory: Integer read GetMaxMemory;
property NumBuffers: Integer read GetNumBuffers;
property DatabasePageSize: Integer read GetDatabasePageSize;
property Database: IibSHDRVDatabase read GetDatabase write SetDatabase;
end;
IibSHDRVDatabase_FIBPlus = interface(IibSHDRVDatabase)
['{314488D2-EF47-417F-8701-5CB6CD75A737}']
end;
IibSHDRVTransaction_FIBPlus = interface(IibSHDRVTransaction)
['{E43739F3-C63A-4A84-80D0-8AA44C9A8BC0}']
end;
IibSHDRVQuery_FIBPlus = interface(IibSHDRVQuery)
['{7D90548B-714C-444A-9C44-6A45B77F2E52}']
end;
IibSHDRVDataset_FIBPlus = interface(IibSHDRVDataset)
['{93EDEE15-D234-4D57-B02E-3C077C13A453}']
end;
IibSHDRVMonitor_FIBPlus = interface(IibSHDRVMonitor)
['{05549889-7EF9-4410-9D0B-77F3A18F8D6A}']
end;
IibSHDRVService_FIBPLus = interface(IibSHDRVService)
['{5FF3A6CF-CFE9-4E53-A11B-C363ADEAA479}']
end;
IibSHDRVDatabase_FIBPlus68 = interface(IibSHDRVDatabase)
['{3BB5B212-0374-4529-A8F5-4065B9B9F561}']
end;
IibSHDRVTransaction_FIBPlus68 = interface(IibSHDRVTransaction)
['{42763643-3BE6-4ABB-8EB6-B5A89903D3FF}']
end;
IibSHDRVQuery_FIBPlus68 = interface(IibSHDRVQuery)
['{688C077E-4044-46DA-803A-1E45BCB5720E}']
end;
IibSHDRVDataset_FIBPlus68 = interface(IibSHDRVDataset)
['{4049B56F-BD1C-465E-BE2F-067A8A7042F3}']
end;
IibSHDRVMonitor_FIBPlus68 = interface(IibSHDRVMonitor)
['{2D3A7681-0896-446F-A33D-2DB63D493A1F}']
end;
IibSHDRVService_FIBPlus68 = interface(IibSHDRVService)
['{3F0B07E2-C18A-41C8-B7FA-1E941AD6F78A}']
end;
IibSHDRVMonitor_IBX = interface(IibSHDRVMonitor)
['{89EC6331-73ED-472C-9D0D-A5DA26B12C18}']
end;
// IibSHDRVSQLParser_IBX = interface(IibSHDRVSQLParser)
// ['{08B7AB43-AAF8-4EA4-A6AE-B3681456A5CD}']
// end;
IibSHDRVSQLParser_FIBPlus = interface(IibSHDRVSQLParser)
['{3DCD4565-B0AD-4D2D-AFBA-261BCE90DDA2}']
end;
IibSHDRVSQLParser_FIBPlus68 = interface(IibSHDRVSQLParser)
['{E806620E-A425-48F4-B320-9CE619AA95A8}']
end;
IibSHDRVPlayer_FIBPlus = interface(IibSHDRVPlayer)
['{A656547A-6FC4-4FA7-B549-9820AB4E0304}']
end;
IibSHDRVPlayer_FIBPlus68 = interface(IibSHDRVPlayer)
['{9CADD7EF-758B-4747-8B3A-9A38FA1B5101}']
end;
IibSHDRVStatistics_FIBPlus = interface(IibSHDRVStatistics)
['{9756CD2B-5DA6-44D4-BD4F-107003B82D5D}']
end;
IibSHDRVStatistics_FIBPlus68 = interface(IibSHDRVStatistics)
['{B8B51A8B-1A9E-4BAB-A7F9-F4947B210F00}']
end;
implementation
end.
|
{***************************************************************************}
{ }
{ Delphi Package Manager - DPM }
{ }
{ Copyright © 2019 Vincent Parrett and contributors }
{ }
{ vincent@finalbuilder.com }
{ https://www.finalbuilder.com }
{ }
{ }
{***************************************************************************}
{ }
{ Licensed under the Apache License, Version 2.0 (the "License"); }
{ you may not use this file except in compliance with the License. }
{ You may obtain a copy of the License at }
{ }
{ http://www.apache.org/licenses/LICENSE-2.0 }
{ }
{ Unless required by applicable law or agreed to in writing, software }
{ distributed under the License is distributed on an "AS IS" BASIS, }
{ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. }
{ See the License for the specific language governing permissions and }
{ limitations under the License. }
{ }
{***************************************************************************}
unit DPM.Console.Types;
interface
(*
config Gets or sets NuGet config values.
delete Deletes a package from the server.
help (?) Displays general help information and help information about other commands.
install Installs a package using the specified sources. If no sources are specified, all sources defined in the NuGet configuration file are used. If the
configuration file specifies no sources, uses the default NuGet feed.
list Displays a list of packages from a given source. If no sources are specified, all sources defined in %AppData%\NuGet\NuGet.config are used. If NuG
et.config specifies no sources, uses the default NuGet feed.
pack Creates a NuGet package based on the specified nuspec or project file.
push Pushes a package to the server and publishes it.
NuGet's default configuration is obtained by loading %AppData%\NuGet\NuGet.config, then loading any nuget.config or .nuget\nuget.config starting f
rom root of drive and ending in current directory.
restore Restores NuGet packages.
setApiKey Saves an API key for a given server URL. When no URL is provided API key is saved for the NuGet gallery.
sources Provides the ability to manage list of sources located in %AppData%\NuGet\NuGet.config
spec Generates a nuspec for a new package. If this command is run in the same folder as a project file (.csproj, .vbproj, .fsproj), it will create a to
kenized nuspec file.
update Update packages to latest available versions. This command also updates NuGet.exe itself.
*)
{$SCOPEDENUMS ON}
type
TDPMCommand = (Cache,
Config,
Delete,
ExitCodes,
Help,
Install,
Uninstall,
Feed,
List,
Pack,
Push,
Restore,
SetAPIKey,
Sign,
Sources,
Spec,
Update,
Verify,
Why,
Info,
None,
Invalid);
const
CommandString : array[TDPMCommand] of string =
('cache',
'config',
'delete',
'exitcodes',
'help',
'install',
'uninstall',
'feed',
'list',
'pack',
'push',
'restore',
'setapikey',
'sign',
'sources',
'spec',
'update',
'verify',
'why',
'info',
'',
'invalid');
function GetCommandFromString(const value : string) : TDPMCommand;
implementation
uses
System.TypInfo;
function GetCommandFromString(const value : string) : TDPMCommand;
var
i : integer;
begin
if value = '' then
exit(TDPMCommand.Help);
i := GetEnumValue(TypeInfo(TDPMCommand),value);
if i <> -1 then
result := TDPMCommand(i)
else
result := TDPMCommand.Invalid;
end;
end.
|
{================================================================================
Copyright (C) 1997-2002 Mills Enterprise
Unit : rmZLIBDataStorage
Purpose : To allow the storage of ZLIB Compressed data within the application
Date : 03-04-2000
Author : Ryan J. Mills
Version : 1.90
Notes : See rmDataStorage.pas for further notes.
================================================================================}
unit rmZLIBDataStorage;
interface
{$I CompilerDefines.INC}
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
rmDataStorage, rmZLIB, rmLibrary;
type
TrmZLIBDataStorage = class(TrmCustomDataStorage)
private
{ Private declarations }
fData : TMemoryStream;
fCompressionLevel: TCompressionLevel;
fOriginalSize: TrmDataStorageLongint;
function GetData: TMemoryStream;
procedure SetOriginalSize(const Value: TrmDataStorageLongint);
protected
{ Protected declarations }
procedure ReadBinaryData(Stream: TStream); override;
procedure WriteBinaryData(Stream: TStream); override;
function GetDataSize: TrmDataStorageLongint; override;
public
{ Public declarations }
constructor create(AOwner:TComponent); override;
destructor destroy; override;
procedure WriteToFile(filename:string); override;
procedure LoadFromFile(FileName:string); override;
procedure WriteToStream(Dest:TStream); override;
procedure ClearData; override;
property Data : TMemoryStream read GetData;
published
{ Published declarations }
property OriginalSize : TrmDataStorageLongint read fOriginalSize write SetOriginalSize;
property CompressionLevel : TCompressionLevel read fCompressionLevel write fCompressionLevel default clDefault;
end;
implementation
{ TrmZLIBDataStorage }
procedure TrmZLIBDataStorage.ClearData;
begin
inherited;
fData.Clear;
fOriginalSize := 0;
end;
constructor TrmZLIBDataStorage.create(AOwner: TComponent);
begin
inherited;
fData := TMemoryStream.Create;
fCompressionLevel := clDefault;
end;
destructor TrmZLIBDataStorage.destroy;
begin
inherited;
fData.free;
end;
function TrmZLIBDataStorage.GetData: TMemoryStream;
begin
fData.Position := 0;
Result := fData;
end;
function TrmZLIBDataStorage.GetDataSize: TrmDataStorageLongint;
begin
result := fData.Size;
end;
procedure TrmZLIBDataStorage.LoadFromFile(FileName: string);
var
InFile : TFileStream;
wCompStream : TrmZLIBCompressionStream;
begin
Inherited;
ClearData;
InFile := TFileStream.Create(filename, fmopenread);
try
fOriginalSize := InFile.Size;
wCompStream := TrmZLIBCompressionStream.create(fCompressionLevel, fData);
try
wCompStream.CopyFrom(InFile, 0);
finally
wCompStream.Free;
end;
finally
InFile.free;
end;
end;
procedure TrmZLIBDataStorage.ReadBinaryData(Stream: TStream);
var
n : longint;
begin
fData.Clear;
Stream.ReadBuffer(n,SizeOf(n));
if n > 0 then
fData.CopyFrom(Stream, n);
end;
procedure TrmZLIBDataStorage.setOriginalSize(const Value: integer);
begin
if (csLoading in componentstate) then
fOriginalSize := Value;
end;
procedure TrmZLIBDataStorage.WriteBinaryData(Stream: TStream);
var
n : longint;
begin
n := fData.Size;
Stream.WriteBuffer(n, sizeof(n));
if n > 0 then
Stream.CopyFrom(fData, 0);
end;
procedure TrmZLIBDataStorage.WriteToFile(filename: string);
var
OutFile : TFileStream;
wCompStream : TrmZLIBDecompressionStream;
begin
OutFile := TFileStream.Create(filename, fmcreate);
try
fData.Position := 0;
wCompStream := TrmZLIBDecompressionStream.create(fData);
try
TrmStream(wCompStream).CopyTo(OutFile, fOriginalSize);
finally
wCompStream.Free;
end;
finally
OutFile.free;
end;
end;
procedure TrmZLIBDataStorage.WriteToStream(Dest: TStream);
var
wCompStream : TrmZLIBDecompressionStream;
begin
fData.Position := 0;
wCompStream := TrmZLIBDecompressionStream.create(fData);
try
TrmStream(wCompStream).CopyTo(Dest, fOriginalSize);
finally
wCompStream.Free;
end;
end;
end.
|
unit ClientAPI.Readers;
interface
uses
System.JSON;
function ImportReaderReportsFromWebService(const token: string): TJSONArray;
implementation
uses
System.SysUtils, System.IOUtils;
function GetContactsFromService(const token: string): TJSONValue;
var
JSONFileName: string;
fname: string;
FileContent: string;
begin
JSONFileName := 'json\readers.json';
if FileExists(JSONFileName) then
fname := JSONFileName
else if FileExists('..\..\'+JSONFileName) then
fname := '..\..\'+JSONFileName
else
raise Exception.Create('Error Message');
FileContent := TFile.ReadAllText(fname,TEncoding.UTF8);
Result := TJSONObject.ParseJSONValue(FileContent);
end;
function ImportReaderReportsFromWebService (const token: string): TJSONArray;
var
jsValue: TJSONValue;
begin
jsValue := GetContactsFromService (token);
if not Assigned(jsValue)then
raise Exception.Create('Can''t connect with Open API service. No data')
else if not( jsValue is TJSONArray ) then
begin
jsValue.Free;
raise Exception.Create('Can''t load data form Open API service.');
end;
Result := jsValue as TJSONArray
end;
end.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.